Differences

This shows you the differences between two versions of the page.

--- language:expressions [2024/07/19 14:25] – [Bit-width rules] rajit
+++ language:expressions [2025/04/21 17:39] (current) – [Structure references] rajit
@@ Line 76: / Line 76: @@
      - //left// + 2^//right// - 1
         * left shift ''<<''
-  * For concatenation, the bit-width is the sum of all the components. For the bitfield extraction, the bitwidth is determined by the number of bits extracted.
+  * For concatenation, the bit-width is the sum of all the components.
+  * For bitfield extraction, the bitwidth is determined by the number of bits extracted.
+==== Idiosyncrasies ====
 While these bit-width rules are nice because you never lose bits, they can have some unexpected consequences. One of the not-so-nice effects of these rules is that, technically, addition is no longer associative in general! For example, consider the following two different assignment statements:
@@ Line 182: / Line 185: @@
   }
 }
+</code>
+===== Structure references =====
+Functions can return [[language:types2:data#pure_structures|pure structures]], and pure structures can have function methods. The expression syntax is rich enough to support these features. As an illustrative example, consider the following:
+<code act>
+deftype mystruct (int a, b)
+{
+     methods {
+          function getsum() : int
+          {
+              chp {
+                  self := a + b
+              }
+         }
+         function addone() : mystruct
+         {
+            chp {
+                self.a := a + 1;
+                self.b := b + 1
+             }
+         }
+    }
+}
+</code>
+We can have expressions of the following form:
+<code act>
+mystruct s;
+int a;
+...
+chp {
+   ...
+   a := s.addone().getsum();
+   ...
+}
 </code>