Differences

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

--- language:impl [2022/05/13 12:40] – rajit
+++ language:impl [2026/08/05 15:30] (current) – [Variant overrides] rajit
@@ Line 245: / Line 245: @@
 representation of the Boolean variable.
+=== Overriding conditional instances and templated types ===
+An instance created in a type definition may be created only under certain circumstances.
+This can occur in templated types, where template parameters can affect the instances within the type.
+The override block has the simple syntax shown above. However, to account for conditional instances,
+the override block directives implicitly check if the instance exists before applying the override. (Note that
+ACT does not permit different types for the same instance name under different conditions.)
+When a type is being overridden by another, the new implementation may have additional template parameters.
+The override syntax above requires the complete list of template parameters to be specified. Instead, we also
+provide a single extension override syntax
+<code act>
++{
+    type<param1,param2,...,paramN>+ id;   // single ID only
+    ...
+ }
+</code>
+The ''+'' indicates that these are //extra// template parameter(s) that should be added to the existing ones that have already been specified for the instance ''id'' in the original type definition.
+==== Variant overrides ====
+If a process has non-strict template parameters, then variants of the process with different non-strict parameter values may need different overrides. While this is straightforward for simple instances, if an array contains a collection of process variants, then this creates a challenge in declaring an override.
+To support this, consider the process below:
+<code act>
+template<pint W | pint VAL>
+defproc addbuf(chan?(int<W>) L; chan!(int<W>) R)
+{
+   int<W> x;
+   chp {
+      *[ L?x; R!(x+VAL) ]
+   }
+}
+</code>
+If we have different implementations of ''addbuf'' depending on the value of ''V'', we can describe this as follows:
+<code act>
+defproc impl_addbuf <: addbuf()
++{
+     ... any overrides for ports here ...
+}
+{
+    /* the default implementation */
+    ...
+}
+| addbuf<W,4> => {
+   /* different implementation when the non-strict parameter has value 4 */
+}
+| addbuf<W,8> => {
+   /* different implementation when the non-strict parameter has value 8 */
+}
+</code>
+This variant override syntax permits variations of the implementation relation based on the specific values of the non-strict template parameters.