@@ -6,30 +6,90 @@ package Core library "prelude/types/optional";
66
77import library "prelude/copy" ;
88import library "prelude/destroy" ;
9+ import library "prelude/operators/as" ;
910import library "prelude/types/bool" ;
11+ import library "prelude/types/maybe_unformed" ;
12+
13+ // TODO: Decide how to expose this in the public API.
14+ private interface OptionalStorage {
15+ let Type:! type ;
16+ fn None () - > Type;
17+ fn Some[self: Self]() - > Type;
18+ fn Has (value: Type) - > bool ;
19+ fn Get (value: Type) - > Self;
20+ }
1021
11- // For now, an `Optional(T)` is stored as a pair of a `bool` and a `T`, with
12- // the `T` left uninitialized if the `bool` is `false`. This isn't a viable
13- // approach in the longer term, but is the best we can do for now.
14- //
15- // TODO: Revisit this once we have choice types implemented in the toolchain.
16- //
1722// TODO: We don't have an approved design for an `Optional` type yet, but it's
1823// used by the design for `Iterate`. The API here is a placeholder.
19- class Optional (T:! Copy ) {
24+ class Optional (T:! OptionalStorage ) {
2025 fn None () - > Self {
21- returned var me: Self;
22- me.has_value = false ;
23- return var;
26+ return T.None () as Self ;
2427 }
25-
2628 fn Some (value: T) - > Self {
27- return {.has_value = true , .value = value};
29+ return value.Some () as Self ;
30+ }
31+ fn HasValue[self: Self]() - > bool {
32+ return T.Has (self as T.Type );
33+ }
34+ fn Get[self: Self]() - > T {
35+ return T.Get (self as T.Type );
2836 }
2937
30- fn HasValue[self: Self]() - > bool { return self.has_value; }
31- fn Get[self: Self]() - > T { return self.value; }
38+ impl T as ImplicitAs (Optional (T)) {
39+ fn Convert[self: T]() - > Optional (T) {
40+ return Some (self);
41+ }
42+ }
3243
33- private var has_value: bool ;
34- private var value: T;
44+ // TODO: Use `private adapt` or `unsafe adapt` once available.
45+ adapt T.Type;
46+ }
47+
48+ // By default, an `Optional(T)` is stored as a pair of a `bool` and a
49+ // `MaybeUnformed(T)`, with the `MaybeUnformed(T)` left uninitialized if the
50+ // `bool` is `false`.
51+ //
52+ // TODO: Revisit this once we have choice types implemented in the toolchain.
53+ private class DefaultOptionalStorage (T:! Copy) {
54+ var value: MaybeUnformed (T);
55+ var has_value: bool ;
56+ }
57+
58+ impl forall [T:! Copy] T as OptionalStorage
59+ where .Type = DefaultOptionalStorage (T) {
60+ fn None () - > DefaultOptionalStorage (T) {
61+ returned var me: DefaultOptionalStorage (T);
62+ me.has_value = false ;
63+ return var;
64+ }
65+ fn Some[self: Self]() - > DefaultOptionalStorage (T) {
66+ returned var me: DefaultOptionalStorage (T);
67+ // TODO: Should be:
68+ // me.value = self as MaybeUnformed(T);
69+ me.value unsafe as T = self;
70+ me.has_value = true ;
71+ return var;
72+ }
73+ fn Has (value: DefaultOptionalStorage (T)) - > bool {
74+ return value.has_value;
75+ }
76+ fn Get (value: DefaultOptionalStorage (T)) - > T {
77+ return value.value unsafe as T ;
78+ }
79+ }
80+
81+ // For pointers, we use a null pointer value as the "None" value. This allows
82+ // `Optional(T*)` to be ABI-compatible with a C++ nullable pointer.
83+ final impl forall [T:! type ] T* as OptionalStorage
84+ where .Type = MaybeUnformed (T* ) {
85+ fn None () - > MaybeUnformed (T* ) = "pointer.make_null" ;
86+ fn Some[self: Self]() - > MaybeUnformed (T* ) {
87+ returned var result: MaybeUnformed (T* );
88+ result unsafe as T * = self;
89+ return var;
90+ }
91+ fn Has (value: MaybeUnformed (T* )) - > bool = "pointer.is_null" ;
92+ fn Get (value: MaybeUnformed (T* )) - > T* {
93+ return value unsafe as T * ;
94+ }
3595}
0 commit comments