* algebra/syntax.spad.pamphlet (SpadAstExports): New.

	* algebra/Makefile.pamphlet (axiom_algebra_layer_user): Add
	SPADXPT.  Update dependency rules.
	* share/algebra: Update algebra databases.

1 files changed, 183 insertions, 0 deletions

diff --git a/src/algebra/syntax.spad.pamphlet b/src/algebra/syntax.spad.pamphlet
index b8d68f84..e38347eb 100644
--- a/src/algebra/syntax.spad.pamphlet
+++ b/src/algebra/syntax.spad.pamphlet
@@ -545,6 +545,188 @@ SpadSyntaxCategory(): Category == AbstractSyntaxCategory
       renderSyntax(x::Syntax)
 @
 
+\subsection{The Exports of SpadAst}
+
+<<category SPADXPT SpadAstExports>>=
+)abbrev category SPADXPT SpadAstExports
+++ Author: Gabriel Dos Reis
+++ Date Created: September 20, 2008
+++ Date Last Modified: September 21, 2008
+++ Description: This category describes the exported
+++   signatures of the SpadAst domain.
+SpadAstExports(): Category == Join(SpadSyntaxCategory, UnionType) with
+   _case: (%, ImportAst()) -> Boolean
+    ++ s case ImportAst holds if `s' represents an `import' statement.
+  autoCoerce: % -> ImportAst()
+    ++ autoCoerce(s) returns the ImportAst view of `s'.  Left at the
+    ++ discretion of the compiler.
+
+   _case: (%, DefinitionAst()) -> Boolean
+    ++ s case DefinitionAst holds if `s' represents a definition.
+  autoCoerce: % -> DefinitionAst()
+    ++ autoCoerce(s) returns the DefinitionAst view of `s'.  Left at the
+    ++ discretion of the compiler.
+
+   _case: (%, MacroAst()) -> Boolean
+    ++ s case MacroAst holds if `s' represents a macro definition.
+  autoCoerce: % -> MacroAst()
+    ++ autoCoerce(s) returns the MacroAst view of `s'.  Left at the
+    ++ discretion of the compiler.
+
+   _case: (%, WhereAst()) -> Boolean
+    ++ s case WhereAst holds if `s' represents an expression with
+    ++ local definitions.
+  autoCoerce: % -> WhereAst()
+    ++ autoCoerce(s) returns the WhereAst view of `s'.  Left at the
+    ++ discretion of the compiler.
+
+   _case: (%, CategoryAst()) -> Boolean
+    ++ s case CategoryAst holds if `s' represents an unnamed category.
+  autoCoerce: % -> CategoryAst()
+    ++ autoCoerce(s) returns the CategoryAst view of `s'.  Left at the
+    ++ discretion of the compiler.
+
+   _case: (%, CapsuleAst()) -> Boolean
+    ++ s case CapsuleAst holds if `s' represents a domain capsule.
+  autoCoerce: % -> CapsuleAst()
+    ++ autoCoerce(s) returns the CapsuleAst view of `s'.  Left at the
+    ++ discretion of the compiler.
+
+   _case: (%, SignatureAst()) -> Boolean
+    ++ s case SignatureAst holds if `s' represents a signature export.
+  autoCoerce: % -> SignatureAst()
+    ++ autoCoerce(s) returns the SignatureAst view of `s'.  Left at the
+    ++ discretion of the compiler.
+
+   _case: (%, AttributeAst()) -> Boolean
+    ++ s case AttributeAst holds if `s' represents an attribute.
+  autoCoerce: % -> AttributeAst()
+    ++ autoCoerce(s) returns the AttributeAst view of `s'.  Left at the
+    ++ discretion of the compiler.
+
+   _case: (%, MappingAst()) -> Boolean
+    ++ s case MappingAst holds if `s' represents a mapping type.
+  autoCoerce: % -> MappingAst()
+    ++ autoCoerce(s) returns the MappingAst view of `s'.  Left at the
+    ++ discretion of the compiler.
+
+   _case: (%, IfAst()) -> Boolean
+    ++ s case IfAst holds if `s' represents an if-statement.
+  autoCoerce: % -> IfAst()
+    ++ autoCoerce(s) returns the IfAst view of `s'.  Left at the
+    ++ discretion of the compiler.
+
+   _case: (%, RepeatAst()) -> Boolean
+    ++ s case RepeatAst holds if `s' represents an repeat-loop.
+  autoCoerce: % -> RepeatAst()
+    ++ autoCoerce(s) returns the RepeatAst view of `s'.  Left at the
+    ++ discretion of the compiler.
+
+   _case: (%, WhileAst()) -> Boolean
+    ++ s case WhileAst holds if `s' represents a while-iterator
+  autoCoerce: % -> WhileAst()
+    ++ autoCoerce(s) returns the WhileAst view of `s'.  Left at the
+    ++ discretion of the compiler.
+
+   _case: (%, InAst()) -> Boolean
+    ++ s case InAst holds if `s' represents a in-iterator
+  autoCoerce: % -> InAst()
+    ++ autoCoerce(s) returns the InAst view of `s'.  Left at the
+    ++ discretion of the compiler.
+
+   _case: (%, CollectAst()) -> Boolean
+    ++ s case CollectAst holds if `s' represents a list-comprehension.
+  autoCoerce: % -> CollectAst()
+    ++ autoCoerce(s) returns the CollectAst view of `s'.  Left at the
+    ++ discretion of the compiler.
+
+   _case: (%, ConstructAst()) -> Boolean
+    ++ s case ConstructAst holds if `s' represents a list-expression.
+  autoCoerce: % -> ConstructAst()
+    ++ autoCoerce(s) returns the ConstructAst view of `s'.  Left at the
+    ++ discretion of the compiler.
+
+   _case: (%, ExitAst()) -> Boolean
+    ++ s case ExitAst holds if `s' represents an exit-expression.
+  autoCoerce: % -> ExitAst()
+    ++ autoCoerce(s) returns the ExitAst view of `s'.  Left at the
+    ++ discretion of the compiler.
+
+   _case: (%, ReturnAst()) -> Boolean
+    ++ s case ReturnAst holds if `s' represents a return-statement.
+  autoCoerce: % -> ReurnAst()
+    ++ autoCoerce(s) returns the ReturnAst view of `s'.  Left at the
+    ++ discretion of the compiler.
+
+   _case: (%, CoerceAst()) -> Boolean
+    ++ s case ReturnAst holds if `s' represents a coerce-expression.
+  autoCoerce: % -> CoerceAst()
+    ++ autoCoerce(s) returns the CoerceAst view of `s'.  Left at the
+    ++ discretion of the compiler.
+
+   _case: (%, PretendAst()) -> Boolean
+    ++ s case PretendAst holds if `s' represents a pretend-expression.
+  autoCoerce: % -> PretendAst()
+    ++ autoCoerce(s) returns the PretendAst view of `s'.  Left at the
+    ++ discretion of the compiler.
+
+   _case: (%, RestrictAst()) -> Boolean
+    ++ s case RestrictAst holds if `s' represents a restrict-expression.
+  autoCoerce: % -> RestrictAst()
+    ++ autoCoerce(s) returns the RestrictAst view of `s'.  Left at the
+    ++ discretion of the compiler.
+
+   _case: (%, SegmentAst()) -> Boolean
+    ++ s case SegmentAst holds if `s' represents a segment-expression.
+  autoCoerce: % -> SegmentAst()
+    ++ autoCoerce(s) returns the SegmentAst view of `s'.  Left at the
+    ++ discretion of the compiler.
+
+   _case: (%, SequenceAst()) -> Boolean
+    ++ s case SequenceAst holds if `s' represents a sequence-of-statements.
+  autoCoerce: % -> SequenceAst()
+    ++ autoCoerce(s) returns the SequenceAst view of `s'.  Left at the
+    ++ discretion of the compiler.
+
+   _case: (%, LetAst()) -> Boolean
+    ++ s case LetAst holds if `s' represents an assignment-expression.
+  autoCoerce: % -> LetAst()
+    ++ autoCoerce(s) returns the LetAst view of `s'.  Left at the
+    ++ discretion of the compiler.
+
+   _case: (%, SuchThatAst()) -> Boolean
+    ++ s case SuchThatAst holds if `s' represents a qualified-expression.
+  autoCoerce: % -> SuchThatAst()
+    ++ autoCoerce(s) returns the SuchThatAst view of `s'.  Left at the
+    ++ discretion of the compiler.
+
+   _case: (%, ColonAst()) -> Boolean
+    ++ s case ColonAst holds if `s' represents a colon-expression.
+  autoCoerce: % -> ColonAst()
+    ++ autoCoerce(s) returns the ColoonAst view of `s'.  Left at the
+    ++ discretion of the compiler.
+ 
+   _case: (%, CaseAst()) -> Boolean
+    ++ s case CaseAst holds if `s' represents a case-expression.
+  autoCoerce: % -> CaseAst()
+    ++ autoCoerce(s) returns the CaseAst view of `s'.  Left at the
+    ++ discretion of the compiler.
+ 
+   _case: (%, HasAst()) -> Boolean
+    ++ s case HasAst holds if `s' represents a has-expression.
+  autoCoerce: % -> HasAst()
+    ++ autoCoerce(s) returns the HasAst view of `s'.  Left at the
+    ++ discretion of the compiler.
+ 
+   _case: (%, IsAst()) -> Boolean
+    ++ s case IsAst holds if `s' represents an is-expression.
+  autoCoerce: % -> IsAst()
+    ++ autoCoerce(s) returns the IsAst view of `s'.  Left at the
+    ++ discretion of the compiler.
+
+@
+
+
 \subsection{The Literal domain}
 
 <<domain LITERAL Literal>>=
@@ -1423,6 +1605,7 @@ MacroAst(): Public == Private where
 
 <<category ASTCAT AbstractSyntaxCategory>>
 <<category SASTCAT SpadSyntaxCategory>>
+<<category SPADXPT SpadAstExports>>
 
 <<domain LITERAL Literal>>
 <<domain HEADAST HeadAst>>