info-dylan up again

[Sean Brunnock <brunnock>]

I have restored the info-dylan mailing list. I have not received
any expalanation from the postmaster at the site in question.

Below are the messages that were sent to info-dylan in the past 24 hours.

Sean Brunnock

Date: Wed, 9 Dec 1992 17:20:59 +0100
From: Bengt Baverman <bengtb@stacken.kth.se>
Message-Id: <199212091620.AA09695@alex.stacken.kth.se>
To: info-dylan@cambridge.apple.com, info-thomas@crl.dec.com
Subject: Using <deque> class in Dylan under Thomas.
Cc: bengtb@stacken.kth.se

I have been playing around with Dylan and Thomas a couple of days now, but I
cannot understand how to use <deque>. Why do I get this response from Thomas:

	? (define q (make <deque>))


	;Value: q

	? (push q 'foo)

	*** ERROR -- runtime-error
	*** Going back to Thomas toplevel...

	? (push q (singleton 'foo))

	*** ERROR -- runtime-error
	*** Going back to Thomas toplevel...

	? (push q 4711)

	*** ERROR -- runtime-error
	*** Going back to Thomas toplevel...
	
Is this me? Have I misunderstod Dylan or is this a bug in Thomas?

Bengt Baverman
bengtb@alex.stacken.kth.se


Date: Wed, 9 Dec 92 11:24:32 EST
From: samp@kurz-ai.com (Sam Pilato)
Message-Id: <9212091624.AA24578@taiyo.kurz-ai.com>
To: info-dylan@cambridge.apple.com, patl@goldfish.mitron.tek.com
In-Reply-To: Patrick Logan's message of Tue, 8 Dec 92 11:21:22 PST
Subject: Eval - Pro's and Con's (was Re: Dylan rather than CL -- why?)


   Inter-application communication and EVAL are two separate issues.

   I may have an application that does not have EVAL, but it will connect
   with another application as a client or a server. For example, a help
   server can be contacted to display help on some topic. EVAL is not
   needed.

   Some other application may have IAC and EVAL, and in particular it may
   allow some other application to connect and do "remote evaluation".
   For example, a window system server may allow clients to connect and
   send functions to the server, extending the capabilities of what the
   server is capable of doing without involving the remote client. (Can
   you say NeWS?)

   In both of samp's examples, the server application is apparently a
   language evaluator and the client wants something evaluated. There is
   no demonstration of IAC having anything in common with EVAL.

I think some type of EVAL _is_ implied by inter-application
communication, but we might mean different things by EVAL.

What can be meant by an EVAL in Dylan?  Dylan doesn't define EVAL, nor
does it even define a correspondence between Dylan source-code syntax
and Dylan evaluable objects (in Lisp, forms), historically mediated in
the Lisp family by a READ contract.

To consider introducing EVAL into Dylan, I assume we're defaulting to
a Lisp-like evaluator, so we're talking about advertising a contract
for the interpretation of some currently unspecified classes of Dylan
objects as function calls (or variables or constants -- or
application-interpreted tokens -- to be resolved).

Who constructs these objects?  The constructors might be explicitly
provided in Dylan; they might be implicitly provided by providing only
a READ function interpreting an external syntax (Dylan syntax or
otherwise); an interface may be defined allowing a foreign body of
code to cause the construction of some Dylan object (such as
isomorphic to an Apple event object) needing interpretation by Dylan
as a foreign function being called.  (I.e., Dylan is the "language" of
the foreign function, but the caller need not know Dylan syntax.)

In the last case, (let's call it ...?) EVALSERVE interprets an object,
dispatching on operator name, class, and class of (recursively
interpreted) operands, as a function call or token resolution.  To me
that counts as evaluation.

(I'm not a computer language implementer, but it seems that the server
aspect of a foreign function interface _could_ get away with not
distinguishing READ from EVAL, and accept only strings (or character
streams) in Dylan syntax.  I guess it depends on whether you want a
foreign _language_ interface as well as or instead of a foreign
_function_ interface.  A foreign _application_ interface implies a
distinction, though, since cooperating applications shouldn't need to
know each other's source-language syntax.)

To me, this topic does seem relevant to Dylan, however small you want
to make it, if Dylan is to be embeddable in larger, foreign,
environments.  I'm asking whether Dylan best provides separate EVAL
and EVALSERVE, or a single eval for both purposes, or neither.

Date: Wed, 9 Dec 92 16:08:51 EST
From: samp@kurz-ai.com (Sam Pilato)
Message-Id: <9212092108.AA24708@taiyo.kurz-ai.com>
To: info-dylan@cambridge.apple.com, patl@goldfish.mitron.tek.com
In-Reply-To: Patrick Logan's message of Wed, 9 Dec 92 09:03:01 PST
Subject: Eval - Pro's and Con's (was Re: Dylan rather than CL -- why?)

   Date: Wed, 9 Dec 92 09:03:01 PST
   From: Patrick Logan <patl@goldfish.mitron.tek.com>

       Date: Wed, 9 Dec 92 11:24:32 EST
       From: samp@kurz-ai.COM (Sam Pilato)

	   [...]

       I think some type of EVAL _is_ implied by inter-application
       communication, but we might mean different things by EVAL.

       [...]

       In the last case, (let's call it ...?) EVALSERVE interprets an object,
       dispatching on operator name, class, and class of (recursively
       interpreted) operands, as a function call or token resolution.  To me
       that counts as evaluation.

   I think we are talking about two different things: an evaluator for
   the Dylan language that is integrated with, changes, and extends the
   same Dylan environment used to implement the application; and an
   evaluator for a language that is implemented in the application, which
   may be a "meta-circular" implementation of Dylan, but it does not
   change or extend the "original" Dylan's environment.

   Does that make sense?

Yes, I think I understand your distinction.  In the first case you're
talking about a traditional EVAL, and in the second case any other
language using Dylan code for its interpreter.

In particular, the "other" language I'm talking about has code objects
something like Apple event objects, and Dylan (or perhaps more likely
an application written in Dylan) handles some subset of those events,
via a kind of "evaluation".

If it handles an application-defined and perhaps foreign-extensible
variety of events, and if the event objects can be mapped to Dylan
"forms" (currently nonexistent), then the language begins to look like
a nice inter-application interface.  I'm wondering whether a native
EVAL in Dylan might serve as a handy, generic, and efficient
implementation of that language.

Date: Thu, 10 Dec 1992 00:27:59 +0100
From: Bengt Baverman <bengtb@stacken.kth.se>
Message-Id: <199212092327.AA10341@alex.stacken.kth.se>
To: bengtb@stacken.kth.se, info-dylan@cambridge.apple.com,
        patl@goldfish.mitron.tek.com
Subject: Re: Using <deque> class in Dylan under Thomas.

>I am using the scc kit for Thomas 1.1 and the <deque> functions work
>as expected. Maybe it is a bug with some other kit or something in
>your installation.

The version of Thomas that I use is:
Thomas 1.1 system running on MacGambit 1.9.1 as printed at startup.

Bengt Baverman
bengtb@alex.stacken.kth.se