diff options
Diffstat (limited to 'src')
| -rw-r--r-- | src/algebra/ChangeLog | 7 | ||||
| -rw-r--r-- | src/algebra/syntax.spad | 49 |
2 files changed, 39 insertions, 17 deletions
diff --git a/src/algebra/ChangeLog b/src/algebra/ChangeLog index 56216965..bea5710e 100644 --- a/src/algebra/ChangeLog +++ b/src/algebra/ChangeLog @@ -1,3 +1,10 @@ +2007-12-05 Gabriel Dos Reis <gdr@cs.tamu.edu> + + * syntax.spad (Syntax): Conversions to Integer, DoubleFloat, + Symbol, and String are not implicit. + (case$Syntax): New function. + (getOperator$Syntax): Adjust. + 2007-12-03 Gabriel Dos Reis <gdr@cs.tamu.edu> * script-parser.spad: New. diff --git a/src/algebra/syntax.spad b/src/algebra/syntax.spad index 0e12d19b..4962975c 100644 --- a/src/algebra/syntax.spad +++ b/src/algebra/syntax.spad @@ -33,7 +33,7 @@ )abbrev domain SYNTAX Syntax ++ Author: Gabriel Dos Reis ++ Date Created: November 10, 2007 -++ Date Last Updated: November 12, 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, @@ -49,18 +49,20 @@ Syntax(): Public == Private where ++ convert(s) returns the s-expression representation of a syntax. convert: SExpression -> % - ++ convert(s) converts an s-expression to syntax. + ++ 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. - convert: Integer -> % + coerce: Integer -> % ++ convert(i) injects the integer value `i' into the syntax domain - convert: DoubleFloat -> % + coerce: DoubleFloat -> % ++ convert(f) injects the float value `f' into the syntax domain - convert: Symbol -> % + coerce: Symbol -> % ++ convert(s) injects the symbol `s' into the syntax domain. - convert: String -> % + coerce: String -> % ++ convert(s) injects the string value `s' into the syntax domain buildSyntax: (Symbol, List %) -> % @@ -79,6 +81,10 @@ Syntax(): Public == Private where getOperands: % -> List % ++ getOperands(x) returns the list of operands to the operator in `x'. + _case: (%, Domain) -> Boolean + ++ x case t returns true if x really is of type t, e.g. + ++ Integer, DoubleFloat, Symbol, String, or %. + Private ==> SExpression add rep(x: %): SExpression == x pretend SExpression @@ -92,36 +98,45 @@ Syntax(): Public == Private where convert(x: SExpression): % == per x - convert(i: Integer): % == - per convert(i)$SExpression + coerce(i: Integer): % == + i pretend % - convert(f: DoubleFloat): % == - per convert(f)$SExpression + coerce(f: DoubleFloat): % == + f pretend % - convert(s: Symbol): % == - per convert(s)$SExpression + coerce(s: Symbol): % == + s pretend % - convert(s: String): % == - per convert(s)$SExpression + coerce(s: String): % == + s pretend % 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. - cons(convert(s)$%, l) pretend % + cons(s::%, l) pretend % buildSyntax(op: %, l: List %): % == cons(op, l) pretend % getOperator x == - s := rep x + atom? rep x => userError "atom as operand to getOperator" + s := car rep x symbol? s => symbol s integer? s => integer s float? s => float s string? s => string s - convert(car s) + convert s getOperands x == s := rep x atom? s => [] [per t for t in destruct cdr s] + + s case t == + symbol? rep s => t is Symbol + integer? rep s => t is Integer + float? rep s => t is DoubleFloat + string? rep s => t is String + pair? rep s => t is % + false |