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
|
\documentclass{article}
\usepackage{axiom}
\begin{document}
\title{\$SPAD/src/algebra any.spad}
\author{Robert S. Sutor}
\maketitle
\begin{abstract}
\end{abstract}
\eject
\tableofcontents
\eject
\section{domain NONE None}
<<domain NONE None>>=
)abbrev domain NONE None
++ Author:
++ Date Created:
++ Change History:
++ Basic Functions: coerce
++ Related Constructors: NoneFunctions1
++ Also See: Any
++ AMS Classification:
++ Keywords: none, empty
++ Description:
++ \spadtype{None} implements a type with no objects. It is mainly
++ used in technical situations where such a thing is needed (e.g.
++ the interpreter and some of the internal \spadtype{Expression}
++ code).
None():SetCategory == add
coerce(none:%):OutputForm == "NONE" :: OutputForm
x:% = y:% == EQ(x,y)$Lisp
@
\section{package NONE1 NoneFunctions1}
<<package NONE1 NoneFunctions1>>=
)abbrev package NONE1 NoneFunctions1
++ Author:
++ Date Created:
++ Change History:
++ Basic Functions: coerce
++ Related Constructors: None
++ Also See:
++ AMS Classification:
++ Keywords:
++ Description:
++ \spadtype{NoneFunctions1} implements functions on \spadtype{None}.
++ It particular it includes a particulary dangerous coercion from
++ any other type to \spadtype{None}.
NoneFunctions1(S:Type): Exports == Implementation where
Exports ==> with
coerce: S -> None
++ coerce(x) changes \spad{x} into an object of type
++ \spadtype{None}.
Implementation ==> add
coerce(s:S):None == s pretend None
@
\section{domain ANY Any}
<<domain ANY Any>>=
)abbrev domain ANY Any
++ Author: Robert S. Sutor
++ Date Created:
++ Change History:
++ Basic Functions: any, domainOf, objectOf, dom, obj, showTypeInOutput
++ Related Constructors: AnyFunctions1
++ Also See: None
++ AMS Classification:
++ Keywords:
++ Description:
++ \spadtype{Any} implements a type that packages up objects and their
++ types in objects of \spadtype{Any}. Roughly speaking that means
++ that if \spad{s : S} then when converted to \spadtype{Any}, the new
++ object will include both the original object and its type. This is
++ a way of converting arbitrary objects into a single type without
++ losing any of the original information. Any object can be converted
++ to one of \spadtype{Any}.
Any(): SetCategory with
any : (SExpression, None) -> %
++ any(type,object) is a technical function for creating
++ an object of \spadtype{Any}. Arugment \spad{type} is a \spadgloss{LISP} form
++ for the type of \spad{object}.
domainOf : % -> OutputForm
++ domainOf(a) returns a printable form of the type of the
++ original object that was converted to \spadtype{Any}.
objectOf : % -> OutputForm
++ objectOf(a) returns a printable form of the
++ original object that was converted to \spadtype{Any}.
dom : % -> SExpression
++ dom(a) returns a \spadgloss{LISP} form of the type of the
++ original object that was converted to \spadtype{Any}.
obj : % -> None
++ obj(a) essentially returns the original object that was
++ converted to \spadtype{Any} except that the type is forced
++ to be \spadtype{None}.
showTypeInOutput: Boolean -> String
++ showTypeInOutput(bool) affects the way objects of
++ \spadtype{Any} are displayed. If \spad{bool} is true
++ then the type of the original object that was converted
++ to \spadtype{Any} will be printed. If \spad{bool} is
++ false, it will not be printed.
== add
Rep := Record(dm: SExpression, ob: None)
printTypeInOutputP:Reference(Boolean) := ref false
obj x == x.ob
dom x == x.dm
domainOf x == x.dm pretend OutputForm
x = y == (x.dm = y.dm) and EQ(x.ob, y.ob)$Lisp
objectOf(x : %) : OutputForm ==
spad2BootCoerce(x.ob, x.dm,
list("OutputForm"::Symbol)$List(Symbol))$Lisp
showTypeInOutput(b : Boolean) : String ==
printTypeInOutputP := ref b
b=> "Type of object will be displayed in output of a member of Any"
"Type of object will not be displayed in output of a member of Any"
coerce(x):OutputForm ==
obj1 : OutputForm := objectOf x
not deref printTypeInOutputP => obj1
dom1 :=
p:Symbol := prefix2String(devaluate(x.dm)$Lisp)$Lisp
atom?(p pretend SExpression) => list(p)$List(Symbol)
list(p)$Symbol
hconcat cons(obj1,
cons(":"::OutputForm, [a::OutputForm for a in dom1]))
any(domain, object) ==
(isValidType(domain)$Lisp)@Boolean => [domain, object]
domain := devaluate(domain)$Lisp
(isValidType(domain)$Lisp)@Boolean => [domain, object]
error "function any must have a domain as first argument"
@
\section{package ANY1 AnyFunctions1}
<<package ANY1 AnyFunctions1>>=
)abbrev package ANY1 AnyFunctions1
++ Author:
++ Date Created:
++ Change History:
++ Basic Functions: coerce, retractIfCan, retractable?, retract
++ Related Constructors: Any
++ Also See:
++ AMS Classification:
++ Keywords:
++ Description:
++ \spadtype{AnyFunctions1} implements several utility functions for
++ working with \spadtype{Any}. These functions are used to go back
++ and forth between objects of \spadtype{Any} and objects of other
++ types.
AnyFunctions1(S:Type): with
coerce : S -> Any
++ coerce(s) creates an object of \spadtype{Any} from the
++ object \spad{s} of type \spad{S}.
retractIfCan: Any -> Union(S, "failed")
++ retractIfCan(a) tries change \spad{a} into an object
++ of type \spad{S}. If it can, then such an object is
++ returned. Otherwise, "failed" is returned.
retractable?: Any -> Boolean
++ retractable?(a) tests if \spad{a} can be converted
++ into an object of type \spad{S}.
retract : Any -> S
++ retract(a) tries to convert \spad{a} into an object of
++ type \spad{S}. If possible, it returns the object.
++ Error: if no such retraction is possible.
== add
import NoneFunctions1(S)
Sexpr:SExpression := devaluate(S)$Lisp
retractable? a == dom(a) = Sexpr
coerce(s:S):Any == any(Sexpr, s::None)
retractIfCan a ==
retractable? a => obj(a) pretend S
"failed"
retract a ==
retractable? a => obj(a) pretend S
error "Cannot retract value."
@
\section{License}
<<license>>=
--Copyright (c) 1991-2002, The Numerical ALgorithms Group Ltd.
--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>>
-- Any and None complete the type lattice. They are also used in the
-- interpreter in various situations. For example, it is always possible
-- to resolve two types in the interpreter because at worst the answer
-- may be Any.
<<domain NONE None>>
<<package NONE1 NoneFunctions1>>
<<domain ANY Any>>
<<package ANY1 AnyFunctions1>>
@
\eject
\begin{thebibliography}{99}
\bibitem{1} nothing
\end{thebibliography}
\end{document}
|
