1  program all_module_features.alpha {
 2      struct Nested {
 3          a: alpha::SharedName,
 4          b: beta::SharedName::[beta::X],
 5          c: gamma::Inner,
 6      }
 7  
 8      transition main() -> u32 {
 9          // Constant name shadowing (alpha::X vs beta::X vs gamma::X)
10          let x1 = alpha::X;
11          let x2 = beta::X;
12          let x3 = gamma::X;
13  
14          // Struct name shadowing (SharedName)
15          let s1 = alpha::SharedName {
16              val: 1,
17          };
18          let s2 = beta::SharedName::[beta::X] {
19              val: [2; beta::X],
20          };
21  
22          // Cross-module inline chaining via main
23          let g = gamma::make_inner(alpha::X + beta::X);
24          let result = gamma::consume_inner(g);
25  
26          // Struct with field type from another module
27          let composed = Nested {
28              a: s1,
29              b: s2,
30              c: g,
31          };
32  
33          // Inline function call that takes struct from another module
34          return x1 + x2 + x3
35               + s2.val[1]
36               + result;
37      }
38  }
39  
40  // --- Next Module: alpha.leo --- //
41  
42  // Constant named X
43  const X: u32 = 2;
44  
45  // Struct with same name as in beta (to test shadowing)
46  struct SharedName {
47      val: u32,
48  }
49  
50  // Inline returning its own struct
51  inline make() -> SharedName {
52      return SharedName { val: 99 };
53  }
54  
55  // --- Next Module: beta.leo --- //
56  
57  // Constant shadowing X from alpha
58  const X: u32 = 3;
59  
60  // Struct with same name but generic
61  struct SharedName::[N: u32] {
62      val: [u32; N],
63  }
64  
65  // Inline using generic struct
66  inline make() -> SharedName::[X] {
67      return SharedName::[X] {
68          val: [5; X],
69      };
70  }
71  
72  // --- Next Module: gamma.leo --- //
73  
74  // Constant shadowing again
75  const X: u32 = 4;
76  
77  // Struct referencing another module’s const and struct in main
78  struct Inner {
79      n: u32,
80  }
81  
82  // Inline returning struct defined here
83  inline make_inner(n: u32) -> Inner {
84      return Inner { n };
85  }
86  
87  inline consume_inner(inner: Inner) -> u32 {
88      return inner.n + X;
89  }