1  /*
  2  seed = 123456789
  3  
  4  [case]
  5  program = "all_types.alpha"
  6  function = "optional_basic_primitives"
  7  input = []
  8  
  9  [case]
 10  program = "all_types.alpha"
 11  function = "array_of_optionals"
 12  input = []
 13  
 14  [case]
 15  program = "all_types.alpha"
 16  function = "optional_array"
 17  input = []
 18  
 19  [case]
 20  program = "all_types.alpha"
 21  function = "optional_struct_field"
 22  input = []
 23  
 24  [case]
 25  program = "all_types.alpha"
 26  function = "optional_struct"
 27  input = []
 28  
 29  [case]
 30  program = "all_types.alpha"
 31  function = "array_of_optional_structs"
 32  input = []
 33  
 34  [case]
 35  program = "all_types.alpha"
 36  function = "nested_optional_structs"
 37  input = []
 38  
 39  [case]
 40  program = "all_types.alpha"
 41  function = "tuples_with_optional_elements"
 42  input = []
 43  
 44  [case]
 45  program = "all_types.alpha"
 46  function = "optional_misc_primitive_types"
 47  input = [] 
 48  
 49  [case]
 50  program = "all_types.alpha"
 51  function = "optional_address"
 52  input = [] 
 53  */
 54  
 55  program all_types.alpha {
 56  
 57      // --- Shared Structs ---
 58      struct OptStruct {
 59          val: u16?,
 60      }
 61  
 62      struct MyStruct {
 63          x: u8,
 64      }
 65  
 66      struct Foo {
 67          x: u8,
 68      }
 69  
 70      struct Inner {
 71          val: u8?,
 72      }
 73  
 74      struct Wrapper {
 75          arr: [Inner?; 2]?,
 76      }
 77  
 78      struct Container {
 79          wrappers: [Wrapper?; 2]?,
 80      }
 81  
 82      struct Top {
 83          container: Container?,
 84      }
 85  
 86      // --- Section 1: Basic Optionals and Inference ---
 87      transition optional_basic_primitives() -> u32 {
 88          let a: u32? = 10;
 89          let b: u32? = none;
 90          let c: u32 = a.unwrap();
 91          let d: u32 = b.unwrap_or(42);
 92          return c + d; // 10 + 42 = 52
 93      }
 94  
 95      // --- Section 2: Arrays of Optionals ---
 96      transition array_of_optionals() -> u8 {
 97          let arr: [u8?; 3] = [1, none, 3];
 98          let sum = arr[0].unwrap_or(10)
 99                    + arr[1].unwrap_or(20)
100                    + arr[2].unwrap_or(30);
101          return sum; // 1 + 20 + 3 = 24
102      }
103  
104      // --- Section 3: Optional Arrays ---
105      transition optional_array() -> u128 {
106          let arr_opt: [u128?; 2]? = [1000, none];
107          let arr_opt2: [u128?; 3]? = [42; 3];
108          let first =   arr_opt.unwrap()[0].unwrap_or(10) 
109                      + arr_opt.unwrap()[1].unwrap_or(11) 
110                      + arr_opt2.unwrap()[0].unwrap_or(12)
111                      + arr_opt2.unwrap()[2].unwrap_or(13);
112          return first;
113      }
114  
115      // --- Section 4: Structs with Optional Fields ---
116      transition optional_struct_field() -> u16 {
117          let s = OptStruct { val: none };
118          return s.val.unwrap_or(123); // 123
119      }
120  
121      // --- Section 5: Optional Structs ---
122      transition optional_struct() -> u8 {
123          let s: MyStruct? = MyStruct { x: 5 };
124          return s.unwrap().x; // 5
125      }
126  
127      // --- Section 6: Arrays of Optional Structs ---
128      transition array_of_optional_structs() -> u8 {
129          let arr: [Foo?; 2] = [Foo { x: 10 }, none];
130          return arr[0].unwrap().x; // 10
131      }
132  
133      // --- Section 7: Nested Optionals in Structs & Arrays ---
134      transition nested_optional_structs() -> u8 {
135          let inner = Inner { val: 10 };
136          let wrapper = Wrapper { arr: [inner, none] };
137          let container = Container { wrappers: [wrapper, none] };
138          let top = Top { container };
139  
140          return top.container.unwrap()
141              .wrappers.unwrap()[0].unwrap()
142              .arr.unwrap()[0].unwrap()
143              .val.unwrap(); // 10
144      }
145  
146      // --- Section 8: Tuples with Optional Elements ---
147      transition tuples_with_optional_elements() -> u32 {
148          let t1: (u32, u32?) = (100, 200);
149          let t2: (u32, u32?) = (300, none);
150  
151          let sum = t1.0 + t1.1.unwrap_or(0)
152                  + t2.0 + t2.1.unwrap_or(50);
153          return sum; // 100 + 200 + 300 + 50 = 650
154      }
155  
156      // --- Section 9: Optionals with address, group, field, scalar, signature ---
157      transition optional_misc_primitive_types() -> (group, field, scalar) {
158          let gr: group? = 0;
159          let fl: field? = 1;
160          let sc: scalar? = 2;
161          
162          return (
163              gr.unwrap(),
164              fl.unwrap_or(2),
165              sc.unwrap(),
166          );
167      }
168  
169      // --- Section 10: Optionals with Address ---
170      struct AddrStruct { a: address, b: address? }
171      struct InnerAddr { val: address? }
172      struct WrapperAddr { inner: InnerAddr }
173      transition optional_address() -> (address, address, address, address) {
174          // Case 1: Direct optional address
175          let a: address? = none;
176          let b: address? = ax10qerras5799u6k7rjtc9y3hcwxuykr45qra7x7dp6jgnc0923czqm0lgta;
177          let val1 = b.unwrap_or(a.unwrap_or(ax10qerras5799u6k7rjtc9y3hcwxuykr45qra7x7dp6jgnc0923czqm0lgta));
178  
179          // Case 2: Struct containing address and optional address
180          let s = AddrStruct { 
181              a: ax10qerras5799u6k7rjtc9y3hcwxuykr45qra7x7dp6jgnc0923czqm0lgta, 
182              b: none 
183          };
184          let val2 = s.b.unwrap_or(s.a);
185  
186          // Case 3: Optional struct containing address
187          let s_opt: AddrStruct? = AddrStruct { 
188              a: ax10qerras5799u6k7rjtc9y3hcwxuykr45qra7x7dp6jgnc0923czqm0lgta, 
189              b: none 
190          };
191          let val3 = s_opt.unwrap().a;
192  
193          // Case 4: Nested struct with optional address field
194  
195          let wrapper = WrapperAddr { inner: InnerAddr { val: ax10qerras5799u6k7rjtc9y3hcwxuykr45qra7x7dp6jgnc0923czqm0lgta } };
196          let val4 = wrapper.inner.val.unwrap();
197  
198          // Just return one of the addresses to satisfy return type
199          return (val1, val2, val3, val4);
200      }
201  
202      @noupgrade
203      async constructor() {}
204  }