aboutsummaryrefslogtreecommitdiff
path: root/src/algebra/syntax.spad.pamphlet
blob: c664050028439ca5acfec16d597de2b3adf52357 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
\documentclass{article}
\usepackage{axiom}

\author{Gabriel Dos~Reis}

\begin{document}

\begin{abstract}
\end{abstract}

\tableofcontents
\eject

\section{domain Syntax}

<<domain SYNTAX Syntax>>=
import UnionType
import SetCategory
import Boolean
import Integer
import DoubleFloat
import Symbol
import SExpression
)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 domain, general enough for
++ building complete representation of Spad programs as objects 
++ of a term algebra built from ground terms of type integers, foats, 
++ symbols, and strings.  
++ This domain differs from InputForm in that it represents
++ any entity in a Spad program, not just expressions.
++ Related Constructors: Boolean, Integer, Float, Symbol, String, SExpression.
++ See Also: SExpression, SetCategory.
++ The equality supported by this domain is structural.
++ Fixme: Provide direct support for boolean values, arbritrary 
++        precision float point values.
Syntax(): Public == Private where
  Public ==> Join(UnionType, SetCategory) 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 cells 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 value returned 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 `x' is not an atomic syntax.

    _case: (%, [|Integer|]) -> Boolean
      ++ x case Integer is true if `x' really is an Integer 

    _case: (%, [|DoubleFloat|]) -> Boolean
      ++ x case DoubleFloat is true if `x' really is a DoubleFloat

    _case: (%, [|Symbol|]) -> Boolean
      ++ x case Symbol is true if `x' really is a Symbol

    _case: (%, [|String|]) -> Boolean
      ++ x case String is true if `x' really is a String

  Private ==> SExpression add
    rep(x: %): SExpression ==
      x pretend SExpression

    per(x: SExpression): % ==
      x pretend %

    x = y ==
      EQUAL(x,y)$Lisp @ Boolean

    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>>=
import SetCategory
import Symbol
import List Syntax
)abbrev domain CTORCALL ConstructorCall
++ Author: Gabriel Dos Reis
++ Date Created: January 19, 2008
++ Date Last Updated: July 03, 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 == SetCategory 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 == List Syntax

    constructorName x ==
      (first rep x)::Symbol

    arguments x ==
      rest rep x

    x = y ==
      rep x = rep y

    coerce x ==
      outputDomainConstructor(x)$Lisp
@

\section{The Signature domain}

<<domain SIG Signature>>=
import SetCategory
import ConstructorCall
)abbrev domain SIG Signature
++ Author: Gabriel Dos Reis
++ Date Created: January 10, 2008
++ Date Last Updated: July 14, 2008
++ Description: This is the datatype for operation signatures as
++ used by the compiler and the interpreter.
++ See also: ConstructorCall, Domain.
Signature(): Public == Private where
  Public == SetCategory with
    target: % -> ConstructorCall
      ++ target(s) returns the target type of the signature `s'.
    source: % -> List ConstructorCall
      ++ source(s) returns the list of parameter types of `s'.
  Private == add
    Rep == List ConstructorCall
    target x ==
      first rep x
    source x ==
      rest rep x
    x = y ==
      rep x = rep y
    coerce(x: %): OutputForm ==
      rarrow([s::OutputForm for s in source x]::OutputForm,
         target(x)::OutputForm)$OutputForm
@

\section{domain ElaboratedExpression}

<<domain ELABEXPR ElaboratedExpression>>=
import Boolean
import Symbol
import ConstructorCall
import List
import SExpression
)abbrev domain ELABEXPR ElaboratedExpression
++ Author: Gabriel Dos Reis
++ Date Created: January 19, 2008
++ Date Last Updated: January 20, 2008
++ Description: This domains an expresion as elaborated by the interpreter.
++ See Also: 
ElaboratedExpression(): Public == Private where
  Public ==> CoercibleTo OutputForm with
    type: % -> ConstructorCall
      ++ type(e) returns the type of the expression as computed by
      ++ the interpreter.
    constant?: % -> Boolean
      ++ constant?(e) returns true if `e' is a constant.
    getConstant: % -> Union(SExpression,"failed")
      ++ getConstant(e) retrieves the constant value of `e'e.
    variable?: % -> Boolean
      ++ variable?(e) returns true if `e' is a variable.
    getIdentifier: % -> Union(Symbol,"failed")
      ++ getIdentifier(e) retrieves the name of the variable `e'.
    callForm?: % -> Boolean
      ++ callForm?(e) is true when `e' is a call expression.
    getOperator: % -> Union(Symbol, "failed")
      ++ getOperator(e) retrieves the operator being invoked in `e',
      ++ when `e' is an expression.  
    getOperands: % -> Union(List %, "failed")
      ++ getOperands(e) returns the list of operands in `e', assuming it
      ++ is a call form.

  Private ==> add
    isAtomic(x: %): Boolean ==
      ATOM(x)$Lisp @ Boolean

    type x ==
      getMode(x)$Lisp @ ConstructorCall

    callForm? x ==
      CONSP(x)$Lisp @ Boolean

    getOperator x ==
      op: SExpression := getUnnameIfCan(x)$Lisp
      null? op => "failed"
      op pretend Symbol

    constant? x ==
      isAtomic x and 
        EQ(getUnnameIfCan(x)$Lisp, _$immediateDataSymbol$Lisp)$Lisp : Boolean

    getConstant x ==
      constant? x => getValue(x)$Lisp @ SExpression
      "failed"

    variable? x ==
      isAtomic x and not constant? x
   
    getIdentifier x ==
      variable? x => symbol (getUnname(x)$Lisp@SExpression)
      "failed"
@


\section{SpadAbstractSyntaxCategory}

<<category ASTCAT AbstractSyntaxCategory>>=
import SetCategory
import CoercibleTo Syntax
)abbrev category ASTCAT AbstractSyntaxCategory
++ Author: Gabriel Dos Reis
++ Date Created: July 5, 2008
++ Date Last Modified: July 5, 2008
++ Description: This is the category of Spad abstract syntax trees.
AbstractSyntaxCategory(): Category == 
    Join(SetCategory, CoercibleTo Syntax)
  add
    coerce(x: %): Syntax ==
      x pretend Syntax
    coerce(x: %): OutputForm ==
      x::Syntax::OutputForm 
@

\subsection{The HeadAst domain}

<<domain HEADAST HeadAst>>=
import AbstractSyntaxCategory
import Symbol
import List Symbol
)abbrev domain HEADAST HeadAst
++ Author: Gabriel Dos Reis
++ Date Created: November 10, 2007
++ Date Last Modified: July 2008
++ Description: This domain represents the header of a definition.
HeadAst(): Public == Private where
  Public == AbstractSyntaxCategory with
    headAst: List Symbol -> %
      ++ headAst [f,x1,..,xn] constructs a function definition header.
    name: % -> Symbol
      ++ name(h) returns the name of the operation defined defined.
    parameters: % -> List Symbol
      ++ parameters(h) gives the parameters specified in the
      ++ definition header `h'.
  Private == add
    Rep == List Symbol
    headAst h == per h
    name h == first rep h
    parameters h == rest rep h
@

\section{License}

<<license>>=
--Copyright (C) 2007-2008, 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>>
<<domain ELABEXPR ElaboratedExpression>>

<<category ASTCAT AbstractSyntaxCategory>>
<<domain HEADAST HeadAst>>
@

\end{document}