Differences

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

Link to this comparison view

Both sides previous revisionPrevious revision
Next revision		Previous revision
language:namespaces [2020/05/01 20:49] – [Importing namespaces] rajitlanguage:namespaces [2024/07/27 16:52] (current) – [Renaming namespaces] rajit
Line 12: Line 12:
 A namespace is created by using the ''namespace'' construct. A namespace is created by using the ''namespace'' construct.
  
-<code>+<code act>
 namespace lib { namespace lib {
 ... ...
Line 38: Line 38:
 namespaces is shown below. namespaces is shown below.
  
-<code>+<code act>
 namespace datapath { namespace datapath {
     export defproc bus_interface(...) { ... }     export defproc bus_interface(...) { ... }
Line 64: Line 64:
 the entire namespace ''adder'' can be exported as follows: the entire namespace ''adder'' can be exported as follows:
  
-<code>+<code act>
 namespace datapath { namespace datapath {
     export defproc bus_interface(...) { ... }     export defproc bus_interface(...) { ... }
Line 93: Line 93:
 The basic form of import statement is shown below: The basic form of import statement is shown below:
  
-<code>+<code act>
 import "channel.act"; import "channel.act";
 ... ...
Line 111: Line 111:
 hierarchy. The import statement hierarchy. The import statement
  
-<code>+<code act>
 import processor::lib; import processor::lib;
 </code> </code>
Line 117: Line 117:
 is equivalent to the following: is equivalent to the following:
  
-<code>+<code act>
 import "processor/lib/_all_.act"; import "processor/lib/_all_.act";
 </code> </code>
Line 123: Line 123:
 It assumes that the file ''_all_.act'' in the directory It assumes that the file ''_all_.act'' in the directory
 ''processor/lib'' contains all the definitions corresponding to the ''processor/lib'' contains all the definitions corresponding to the
-''processor::lib'' namespace. More generally, an import statement+''processor::lib'' namespace. More precisely, an import statement
  
-<code>+<code act>
 import foo; import foo;
 </code> </code>
Line 139: Line 139:
 ===== Opening namespaces ===== ===== 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 own namespace to avoid naming conflicts. This situation can result in
 very long type names. Plus it would be more bookkeeping to have to very long type names. Plus it would be more bookkeeping to have to
 create a test environment for the types within, say, create a test environment for the types within, say,
 ''processor::lib''---not just because of the long type names, but ''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"; import "lib.act";
 open processor::lib; open processor::lib;
Line 176: Line 164:
 at the beginning of an ACT file. 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''.
language/namespaces.1588366191.txt.gz · Last modified: (external edit)
Except where otherwise noted, content on this wiki is licensed under the following license: GNU Free Documentation License 1.3


  • Show page
  • Old revisions
  • Backlinks
  • Recent Changes
  • Media Manager
  • Sitemap