Differences

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

--- language:namespaces [2020/06/19 07:26]
rajit [Importing namespaces]
+++ language:namespaces [2024/07/27 12:52] (current)
rajit [Renaming namespaces]
@@ Line 12: / Line 12: @@
 A namespace is created by using the ''namespace'' construct.
-<code>
+<code act>
 namespace lib {
 ...
@@ Line 38: / Line 38: @@
 namespaces is shown below.
-<code>
+<code act>
 namespace datapath {
     export defproc bus_interface(...) { ... }
@@ Line 64: / Line 64: @@
 the entire namespace ''adder'' can be exported as follows:
-<code>
+<code act>
 namespace datapath {
     export defproc bus_interface(...) { ... }
@@ Line 93: / Line 93: @@
 The basic form of import statement is shown below:
-<code>
+<code act>
 import "channel.act";
 ...
@@ Line 111: / Line 111: @@
 hierarchy. The import statement
-<code>
+<code act>
 import processor::lib;
 </code>
@@ Line 117: / Line 117: @@
 is equivalent to the following:
-<code>
+<code act>
 import "processor/lib/_all_.act";
 </code>
@@ Line 125: / Line 125: @@
 ''processor::lib'' namespace. More precisely, an import statement
-<code>
+<code act>
 import foo;
 </code>
@@ Line 139: / Line 139: @@
 ===== Opening namespaces =====
-If there are two different files that define the same namespace (say defined in multiple projects), importing both the files may result in type conflicts. Consider a scenario where we have two ''lib'' namespaces defined for two different projects, but  both have useful circuits that we would like to re-use in a third project. If ''lib1.act'' and ''lib2.act'' both contain namespace ''lib'', importing both would take the union of the definitions in the two files, potentially resulting in errors.
+If  a project has many different people working on it, it can be convenient
+to have each component/module in their
-To resolve this issue, ACT provides a way to rename a namespace that has been imported.
-<code>
-import "lib1.act";
-open lib -> lib1;
-import "lib2.act";
-open lib -> lib2;
-</code>
-In this example, the ''open'' construct enables one to rename a namespace. Once this
-has occured, there cannot be any naming conflicts. This version of ''open'' is a renaming construct; after the open statement, the old name for the namespace is eliminated.
-A second issue is one that is more about convenience. Consider a
-project that has many different people working on it, each in their
 own namespace to avoid naming conflicts. This situation can result in
 very long type names. Plus it would be more bookkeeping to have to
 create a test environment for the types within, say,
 ''processor::lib''---not just because of the long type names, but
-because not all types might be exported! In this case we can say:
+because not all types might be exported!
-<code>
+As a syntactic convenience, we can say:
+<code act>
 import "lib.act";
 open processor::lib;
@@ Line 176: / Line 164: @@
 at the beginning of an ACT file.
+===== Renaming namespaces =====
+If there are two different files that define the same namespace (say defined in multiple projects), importing both the files may result in type conflicts. Consider a scenario where we have two ''lib'' namespaces defined for two different projects, but  both have useful circuits that we would like to re-use in a third project. If ''lib1.act'' and ''lib2.act'' both contain namespace ''lib'', importing both would take the union of the definitions in the two files, potentially resulting in errors.
+To resolve this issue, ACT provides a way to rename a namespace that has been imported.
+<code act>
+import "lib1.act";
+open lib -> lib1;
+import "lib2.act";
+open lib -> lib2;
+</code>
+In this example, the ''open'' construct enables one to rename a namespace. Once this
+has occured, there cannot be any naming conflicts. This version of ''open'' is a renaming construct; after the open statement, the old name for the namespace is eliminated.
+Another renaming scenario that can be useful is to move a namespace into another one.
+<code act>
+import lib;
+import lib => priv;
+</code>
+The first import statement above loads in the ''lib'' namespace. The second moves the namespace //into// ''priv''. If ''priv'' doesn't exist as a namespace, it is created. With this sequence, the original ''lib'' is now accessed as ''priv::lib''.