Differences

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

--- language:types [2021/11/21 16:25] – rajit
+++ language:types [2025/04/21 14:32] (current) – [Parameterized types] rajit
@@ Line 50: / Line 50: @@
 name followed by a comma-separated list of identifier names.
-<code>
+<code act>
 bool a,b,c,n1,n1x2;
 pint x,y,z;
@@ Line 60: / Line 60: @@
 to have more than one instantiation of a variable in the same scope.
-<code>
+<code act>
 bool a;
 pint a;
+</code>
+<code>
 -[ERROR]-> Duplicate instance for name `a'
 </code>
@@ Line 68: / Line 70: @@
 A parameter instantiation can be accompanied by a single //initializer//
 which initializes the value of a variable.
-<code>
+<code act>
 pint a=5, c=8;
 preal b=8.9;
@@ Line 76: / Line 78: @@
 Using constructs such as
-<code>
+<code act>
 pint a=c, c=5;
+</code>
+<code>
 -[ERROR]-> The identifier `c' does not exist in the current scope
 </code>
@@ Line 92: / Line 96: @@
 examples of creating arrays are shown below:
-<code>
+<code act>
 int ar1[4]
 preal ar2[7]
@@ Line 107: / Line 111: @@
 specifications, as shown below.
-<code>
+<code act>
 int ar4[5*3]
 preal ar5[7*x+(y%2)-p] // here x, y, and p must be integer parameter types
@@ Line 115: / Line 119: @@
 type. Variables used must always be parameter types (typically ''pint'').
-<code>
+<code act>
 preal a = 4.3;
 bool ar6[7*a+5];
+</code>
+<code>
 -[ERROR]-> Expression must be of type int
 </code>
@@ Line 125: / Line 131: @@
 the example below.
-<code>
+<code act>
 bool x[5,3];
 bool y[1..6][9][2..10];
@@ Line 136: / Line 142: @@
 aforementioned array is shown below.
-<code>
+<code act>
 bool n[4..4], n[6..6];
 </code>
@@ Line 144: / Line 150: @@
 dynamically extended in ACT.
-<code>
+<code act>
 bool n[5];
 bool n[10..12]; // n is now defined at positions 0 to 4, 10 to 12
@@ Line 152: / Line 158: @@
 ''m'' at positions ''[6][5]'', ''[6][6]'', ..., ''[6][10]''.
-<code>
+<code act>
 bool m[6..6][5..10]
 </code>
@@ Line 158: / Line 164: @@
 Note that this is quite different from the statement
-<code>
+<code act>
 bool m[6][5..10];
 </code>
@@ Line 168: / Line 174: @@
 initializers.
-<code>
+<code act>
 bool x[10];
 bool y[10] = x;
+</code>
+<code>
 -[ERROR]-> Connection can only be specified for non-array instances
 </code>
@@ Line 179: / Line 187: @@
+===== Parameterized built-in types =====
+Parameterized types give ACT considerable flexibility in type
+definitions. Parameterized types come in two flavors: built-in types,
+and user-defined types. For user-defined types, ACT guarantees
+that the order in which parameters are created and initialized is from
+left to right. Therefore, one can use the value of one parameter in
+the definition of another one.
+Although we have been describing the types ''int'' and ''chan''
+as simple types, they are in fact parameterized. Omitting the
+parameters makes ACT use implicit default parameters for both of
+them.
+The ''int'' type is parameterized by the number of bits used to
+specify the integer. This bit-width can be specified using angle
+brackets, as shown below:
+<code act>
+int<1> x; // x is a one bit integer
+int<37> y; // y is a thirty-seven bit integer
+</code>
+When interpreting these bits as integers, ACT assumes an unsigned
+binary representation. The default bit-width is thirty-two.
+The channel type ''chan'' can be parameterized by the type that is
+being sent and received on the channel.
+<code act>
+chan(bool) x; // x is a Boolean channel
+chan(int<16>) y; // y is a 16-bit integer channel
+</code>
+The default data type for a channel is assumed to be the default
+''int'', namely ''int<32>''.
+Channels are almost always unidirectional, with data being transferred from sender to receiver.
+In a few cases, it is useful to be able to transfer data from the sender to the receiver, and from the
+receiver to the sender in one channel action. To declare a channel where data are transferred in
+both directions, use:
+<code act>
+// a bool is transferred from sender to receiver, and
+// an int is transferred from the receiver to the sender
+chan(bool,int) x;
+</code>
+These are sometimes called //exchange channels//, since data is exchanged between the sender and receiver.
+Another built-in data type is the //enumeration// type. An
+enumeration type corresponds to integer-valued variables with a
+restricted range.
+<code act>
+enum<5> x; // x can take on values 0, 1, 2, 3, 4
+</code>
+For convenience, these values are treated as integers for the purposes
+of expressions. Also, enumerations that have power-of-two ranges are
+type-equivalent to the approprate ''int'' type. For instance,
+''enum<2>'' is equivalent to ''int<1>''. Enumerations are
+useful when specifying a data value that is a one-hot code.
+===== Directional types =====
+Data and channel types also support access permissions in terms of valid
+operations on the types. To illustrate this, consider the simplest data
+type, namely a ''bool''. There are three different ways a ''bool''
+type can be defined, and they are shown below:
+<code act>
+bool x;  // Boolean that may be read or written
+bool! y; // Boolean that must be written, and may be read
+bool? z; // Boolean that must be read, and cannot be written
+</code>
+The ''!'' and ''?'' suffixes constrain the way in which the type
+can be accessed. The primary use of this is in port lists, where one can
+specify what variables are read and written by a process. The same
+syntax can be used (with the same meaning) for user-defined data types.
+The following example shows a possible definition for a two-input nand
+gate that takes two inputs ''a'' and ''b'', and produces its
+output on ''c''.
+<code act>
+defcell nand2 (bool? a, b; bool! c) { ... }
+</code>
+Channels support a similar syntax, but the meaning is slightly
+different.
+<code act>
+chan(int) x;  // Sends or receives are permitted
+chan!(int) y; // Only sends permitted
+chan?(int) z; // Only receives permitted
+</code>
+Again, the same syntax is valid for user-defined channels. These
+constructs are useful in libraries for additional error checking, and
+conveying more information to the user of the library.