----boundary-LibPST-iamunique-1896121287_-_-
Content-type: text/plain
I second to keep procedure types as part of the language.
Here is my example for illustrating that the old tradition of procedure
types allows for compact, intuitive, artifact free, and very readable
code. This is (portion of) a Thread Interface for Component Pascal.
If we follow Modula3 style for a Thread Interface, we would have:
MODULE Threads;
TYPE Closure* = POINTER TO ABSTRACT RECORD ... END;
PROCEDURE (cl: Closure) Apply*, NEW, ABSTRACT;
PROCEDURE Fork* (cl: Closure); ... END Fork;
Then, What you need to do to start a new thread?.
Well, in the declaration part, you need to: 1)- define a Closure
subtype, say Cl = POINTER TO RECORD (Threads.Closure) END; and 2)-
Implement Cl.Apply procedure (which is going to be the thread body);
then at execution time, you need to: 1)- Create an instance "cl" of
"Cl", 2)- Call procedure "Fork" passing "cl" as parameter. These steps
do not seem to be a great deal; nonetheless, there is a simpler
approach: not to follow Modula3 OO style:
MODULE Threads;
TYPE Thread* = PROCEDURE;
PROCEDURE Fork* (t: Thread); ... END Fork;
What you need now to start a new thread?.
Declare the procedure which will serve as the thread body, say "Th" (or
do not declare it, may be it already exist in some library). You are
done, just fork it: Threads.Fork (Th).
I did not overload this small example with passing parameters to
threads, but that is easy to cope with. Neither I had mentioned that
when one comes to implement Fork, the function WinApi.CreateThread
requires a procedure (not a method) as one of its parameters.
Cheers,
René Dorta.
Universidad de Carabobo. Valencia. Venezuela.
Stan Warford wrote:
> Robert,
> Thanks for your note. But someone please help me understand this.
> I proposed to define the function
>
> TYPE
> Function* = POINTER TO ABSTRACT RECORD END;
>
> PROCEDURE (f: Function) ValueOf* (x: REAL): REAL, NEW, ABSTRACT;
>
> and use it as
>
> TYPE
> MyFunction = POINTER TO RECORD (NumericalProcessor.Function) END;
>
> I am trying to understand why this is so different from procedure
> types. The above literally defines a procedure type and allows
> you to pass a procedure as a parameter.
>
> (1) Is the problem one of requiring all the math functions in the library
> to be this type if you are going to be able to pass them as parameters?
> Would it be a major complication to have to wrap the functions this way?
>
> (2) Is it a convenience problem of having to write
>
> f.ValueOf (min)
>
> instead of
>
> f (min)
>
> I can understand your point if the answer is yes to either of these
> questions, although it seems that (1) would be the most problematic.
> Are these two points why you say that procedure types are simple
> and direct? Or are there some other complications?
>
> Thanks for everybody's feedback.
> Cheers,
> Stan
>
>>>> Stan:
>>>>
>>
>>>>> With object-orientation, procedure types are redundant and should
>>>>> be eliminated, IMHO. You should design your numerical processing ...
>>>>
>>
>>>> I do not disagree with your example, but who would ever use this
>>>> approach?
>>>> Your book on OOP is not among those that define numerical analysis.
>>>> "Numerical Recipes" are the foundation. It goes back to
>>>> Fortran-IV. If
>>>> anyone wants to calculate some integral or a special function,
>>>> they will
>>>> read Press & Teukolsky, not S.Warford.
>>>
>>
>>>> Along the lines of realism: one of our treasures is the
>>>
>>
>>>> huge collection of
>>>> numerical software published and maintained by R.Campbell.
>>>
>>
>>>> Please keep the
>>>> compiler compatible with his collection, not the other way around.
>>>>
>>
>>>> Wojtek
>>>
>>
>> By one of those ironies that make life interesting
>> Wojtek has chosen a bad example. In my Subsystem Lib
>> almost all the numerical stuff is procedural EXCEPT
>> the integrators and root finders.
>>
>> In contrast ALL the mathematical stuff in Subsystem Algebra
>> is o-o.
>>
>> However I firmly believe that procedure type are sometimes the
>> simple and direct solution to a problem and should be kept.
>> Just ignore people who call them obsolete, they are not.
>>
>> This reminds me of discussions about the merits of recursion
>> verses iteration. Some problems require recursion, most in my
>> area of work are simpler with iteration. I would not want
>> to work in an environment (FORTRAN IV or Lisp) that mandated one
>> or the other.
>>
>> Robert
>
--------------------------------------------
To unsubscribe from this mailing list, send a message containing the word "unsubscribe" to:
blackbox-request{([at]})nowhere.xy
To get a list of valid e-mail commands and instructions on their usage, send a message containing the word "help" to the above address.
Send any problem reports or questions related to this email list to the list owner at
owner-blackbox{([at]})nowhere.xy
Current posting policy:
a) To post you should use the same address by which you are subscribed to the mailing list. That way, the list server will recognize you as subscriber and forward your posting immediately, without creating any overhead.
b) If, for some reason, you cannot post from the address, by which you are subscribed, your message will be moderated to avoid spam. Please understand that moderation will often cause some delay, in particular over weekends or holydays.
----boundary-LibPST-iamunique-1896121287_-_-
Content-type: application/rtf
Content-transfer-encoding: base64
Content-Disposition: attachment; filename="rtf-body.rtf"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----boundary-LibPST-iamunique-1896121287_-_---
Received on Sat Nov 20 2004 - 17:30:29 UTC