aboutsummaryrefslogtreecommitdiff
path: root/src/algebra/syntax.spad.pamphlet
diff options
context:
space:
mode:
authordos-reis <gdr@axiomatics.org>2008-01-20 01:02:10 +0000
committerdos-reis <gdr@axiomatics.org>2008-01-20 01:02:10 +0000
commit8559362639b3460afb49ed8c32dba0a75b9bab71 (patch)
tree29e821f843095ea33dfa61c2568d18077ef3fb7b /src/algebra/syntax.spad.pamphlet
parent2546c17a213f87b5a3cd66b58faf84ac6b6186b0 (diff)
downloadopen-axiom-8559362639b3460afb49ed8c32dba0a75b9bab71.tar.gz
* algebra/syntax.spad.pamphlet: Rename from algebra/syntax.spad.
Add a new domain for constructor instantiation form. * algebra/Makefile.pamphlet (axiom_algebra_layer_1): Include CTORCALL.o (SYNTAX.NRLIB/code.$(FASLEXT)): Remove rule. Now implicit. * share/algebra: Update databases.
Diffstat (limited to 'src/algebra/syntax.spad.pamphlet')
-rw-r--r--src/algebra/syntax.spad.pamphlet285
1 files changed, 285 insertions, 0 deletions
diff --git a/src/algebra/syntax.spad.pamphlet b/src/algebra/syntax.spad.pamphlet
new file mode 100644
index 00000000..e7c2b50b
--- /dev/null
+++ b/src/algebra/syntax.spad.pamphlet
@@ -0,0 +1,285 @@
+\documentclass{article}
+\usepackage{axiom}
+
+\author{Gabriel Dos~Reis}
+
+\begin{document}
+
+\begin{abstract}
+\end{abstract}
+
+\tableofcontents
+\eject
+
+\section{domain Syntax}
+<<domain SYNTAX Syntax>>=
+)abbrev domain SYNTAX Syntax
+++ Author: Gabriel Dos Reis
+++ Date Created: November 10, 2007
+++ Date Last Updated: December 05, 2007
+++ Description: This domain provides a simple, general, and arguably
+++ complete representation of Spad programs as objects of a term algebra
+++ built from ground terms of type boolean, integers, foats, symbols,
+++ and strings. This domain differs from InputForm in that it represents
+++ any entity from a Spad program, not just expressions.
+++ Related Constructors: Boolean, Integer, Float, symbol, String, SExpression.
+++ See Also: SExpression.
+++ Fixme: Provide direct support for boolean values, arbritrary
+++ precision float point values.
+Syntax(): Public == Private where
+ Public ==> Join(UnionType, CoercibleTo(OutputForm)) with
+ convert: % -> SExpression
+ ++ convert(s) returns the s-expression representation of a syntax.
+
+ convert: SExpression -> %
+ ++ convert(s) converts an s-expression to syntax. Note, when `s'
+ ++ is not an atom, it is expected that it designates a proper list,
+ ++ e.g. a sequence of cons cell ending with nil.
+
+ coerce: Integer -> %
+ ++ coerce(i) injects the integer value `i' into the Syntax domain
+
+ coerce: % -> Integer
+ ++ coerce(s) extracts and integer value from the syntax `s'
+ autoCoerce: % -> Integer
+ ++ autoCoerce(s) forcibly extracts an integer value from
+ ++ the syntax `s'; no check performed. To be called only
+ ++ at the discretion of the compiler.
+
+ coerce: DoubleFloat -> %
+ ++ coerce(f) injects the float value `f' into the Syntax domain
+
+ coerce: % -> DoubleFloat
+ ++ coerce(s) extracts a float value from the syntax `s'.
+ autoCoerce: % -> DoubleFloat
+ ++ autoCoerce(s) forcibly extracts a float value from the syntax `s';
+ ++ no check performed. To be called only at the discretion of
+ ++ the compiler
+
+ coerce: Symbol -> %
+ ++ coerce(s) injects the symbol `s' into the Syntax domain.
+
+ coerce: % -> Symbol
+ ++ coerce(s) extracts a symbol from the syntax `s'.
+ autoCoerce: % -> Symbol
+ ++ autoCoerce(s) forcibly extracts a symbo from the Syntax
+ ++ domain `s'; no check performed. To be called only at
+ ++ at the discretion of the compiler.
+
+ coerce: String -> %
+ ++ coerce(s) injects the string value `s' into the syntax domain
+
+ coerce: % -> String
+ ++ coerce(s) extracts a string value from the syntax `s'.
+ autoCoerce: % -> String
+ ++ autoCoerce(s) forcibly extracts a string value from
+ ++ the syntax `s'; no check performed. To be called only at
+ ++ the discretion of the compiler.
+
+ buildSyntax: (Symbol, List %) -> %
+ ++ buildSyntax(op, [a1, ..., an]) builds a syntax object for op(a1,...,an).
+
+ buildSyntax: (%, List %) -> %
+ ++ buildSyntax(op, [a1, ..., an]) builds a syntax object for op(a1,...,an).
+
+ nil?: % -> Boolean
+ ++ nil?(s) is true when `s' is a syntax for the constant nil.
+
+ getOperator: % -> Union(Integer, DoubleFloat, Symbol, String, %)
+ ++ getOperator(x) returns the operator, or tag, of the syntax `x'.
+ ++ The return value is itself a syntax if `x' really is an
+ ++ application of a function symbol as opposed to being an
+ ++ atomic ground term.
+
+
+ getOperands: % -> List %
+ ++ getOperands(x) returns the list of operands to the operator in `x'.
+
+ compound?: % -> Boolean
+ ++ compound? x is true when not an atomic syntax.
+
+ _case: (%, [|Integer|]) -> Boolean
+ ++ x case Integer is true is x really is an Integer
+
+ _case: (%, [|DoubleFloat|]) -> Boolean
+ ++ x case DoubleFloat is true is x really is a DoubleFloat
+
+ _case: (%, [|Symbol|]) -> Boolean
+ ++ x case Symbol is true is x really is a Symbol
+
+ _case: (%, [|String|]) -> Boolean
+ ++ x case String is true is x really is a String
+
+ Private ==> SExpression add
+ rep(x: %): SExpression ==
+ x pretend SExpression
+
+ per(x: SExpression): % ==
+ x pretend %
+
+ s case Integer ==
+ integer? rep s
+
+ s case DoubleFloat ==
+ float? rep s
+
+ s case String ==
+ string? rep s
+
+ s case Symbol ==
+ symbol? rep s
+
+ convert(x: %): SExpression ==
+ rep x
+
+ convert(x: SExpression): % ==
+ per x
+
+ coerce(i: Integer): % ==
+ i pretend %
+
+ autoCoerce(i: %): Integer == -- used for hard coercion
+ i : Integer
+
+ coerce(i: %): Integer ==
+ i case Integer => i
+ userError "invalid conversion target type"
+
+ coerce(f: DoubleFloat): % ==
+ f pretend %
+
+ autoCoerce(f: %): DoubleFloat == -- used for hard coercion
+ f : DoubleFloat
+
+ coerce(f: %): DoubleFloat ==
+ f case DoubleFloat => f
+ userError "invalid conversion target type"
+
+ coerce(s: Symbol): % ==
+ s pretend %
+
+ autoCoerce(s: %): Symbol == -- used for hard coercion
+ s : Symbol
+
+ coerce(s: %): Symbol ==
+ s case Symbol => s
+ userError "invalid conversion target type"
+
+ coerce(s: String): % ==
+ s pretend %
+
+ autoCoerce(s: %): String == -- used for hard coercion
+ s : String
+
+ coerce(s: %): String ==
+ s case String => s
+ userError "invalid conversion target type"
+
+ buildSyntax(s: Symbol, l: List %): % ==
+ -- ??? ideally we should have overloaded operator `per' that convert
+ -- from list of syntax to syntax. But the compiler is at the
+ -- moment defective for non-exported overloaded operations.
+ -- Furthermore, this direct call to `CONS' is currently necessary
+ -- in order to have the Syntax domain compiled as early as possible
+ -- in algebra boostrapping process. It should be removed once
+ -- the bootstrap process is improved.
+ CONS(s,l)$Lisp @ %
+
+ buildSyntax(op: %, l: List %): % ==
+ CONS(op,l)$Lisp @ %
+
+ nil? x ==
+ null? rep x
+
+ getOperator x ==
+ atom? rep x => userError "atom as operand to getOperator"
+ op := car rep x
+ symbol? op => symbol op
+ integer? op => integer op
+ float? op => float op
+ string? op => string op
+ convert op
+
+ compound? x ==
+ pair? rep x
+
+ getOperands x ==
+ s := rep x
+ atom? s => []
+ [per t for t in destruct cdr s]
+@
+
+
+\section{domain ConstructorCall}
+<<domain CTORCALL ConstructorCall>>=
+)abbrev domain CTORCALL ConstructorCall
+++ Author: Gabriel Dos Reis
+++ Date Created: January 19, 2008
+++ Date Last Updated: January 19, 2008
+++ Description: This domains represents a syntax object that
+++ designates a category, domain, or a package.
+++ See Also: Syntax, Domain
+ConstructorCall(): Public == Private where
+ Public ==> CoercibleTo OutputForm with
+ constructorName: % -> Symbol
+ ++ constructorName c returns the name of the constructor
+ arguments: % -> List Syntax
+ ++ arguments returns the list of syntax objects for the
+ ++ arguments used to invoke the constructor.
+
+ Private ==> add
+ rep(x: %): List Syntax ==
+ x pretend List(Syntax)
+
+ constructorName x ==
+ (first rep x)::Symbol
+
+ arguments x ==
+ rest rep x
+
+ coerce x ==
+ outputDomainConstructor(x)$Lisp
+@
+
+
+\section{License}
+<<license>>=
+--Copyright (C) 2007, Gabriel Dos Reis.
+--All rights reserved.
+--
+--Redistribution and use in source and binary forms, with or without
+--modification, are permitted provided that the following conditions are
+--met:
+--
+-- - Redistributions of source code must retain the above copyright
+-- notice, this list of conditions and the following disclaimer.
+--
+-- - Redistributions in binary form must reproduce the above copyright
+-- notice, this list of conditions and the following disclaimer in
+-- the documentation and/or other materials provided with the
+-- distribution.
+--
+-- - Neither the name of The Numerical Algorithms Group Ltd. nor the
+-- names of its contributors may be used to endorse or promote products
+-- derived from this software without specific prior written permission.
+--
+--THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+--IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+--TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+--PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
+--OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+--EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+--PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+--PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+--LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+--NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+--SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+@
+
+<<*>>=
+<<license>>
+<<domain SYNTAX Syntax>>
+<<domain CTORCALL ConstructorCall>>
+@
+
+\end{document}