Re: Looking for Ada Technique Name and References

Re: Looking for Ada Technique Name and References

[Tucker Taft]

John Halleck wrote:
> 
> > John Halleck (nahaj@u.cc.utah.edu) wrote:
> > : I would appreciate it if someone could give me the name and a
> > : print reference for the following technique.
> 
> > Someone Replied:
> 
> >  It is called overloading.
> 
>   It uses overloading, but that was not the technique I was trying
>   to get accross.
> 
>   The technique in question is turning the what is normally written
>   as two function calls  (More or less:)
>       "*" (Transpose (A), B)
>   into a type mark and a single function call to a special function
>   that can handle it all more effeciently.


I've never seen it before, but I would call it "clever" ;-).

(Maybe too clever?  Perhaps a Transpose_And_Multiply(A, B) would be more
explicit...).


-- 
-Tucker Taft   stt@averstar.com   http://www.averstar.com/~stt/
Technical Director, Distributed IT Solutions  (www.averstar.com/tools)
AverStar (formerly Intermetrics, Inc.)   Burlington, MA  USA

Re: Looking for Ada Technique Name and References

[Diana Webster]

This technique is called "composition" in mathematics, i.e., the composition
of two functions,
i.e, sum (average (xnum)).  Most programming languages support this.

John Halleck <nahaj@u.cc.utah.edu> wrote in message
news:88kh6q$j4j$1@coward.ks.cc.utah.edu...
> > John Halleck (nahaj@u.cc.utah.edu) wrote:
> > : I would appreciate it if someone could give me the name and a
> > : print reference for the following technique.
>
> > Someone Replied:
>
> >  It is called overloading.
>
>   It uses overloading, but that was not the technique I was trying
>   to get accross.
>
>   The technique in question is turning the what is normally written
>   as two function calls  (More or less:)
>       "*" (Transpose (A), B)
>   into a type mark and a single function call to a special function
>   that can handle it all more effeciently.
>
> >
> > : Background:
> >
> > :    Many matrix methods are written in the form  A := Transpose(B)*C
> > :    But, actually forming the transpose is expensive, and you are
better
> > :    off just writing a second matrix multiply routine that takes the
> > :    two matrices and treats the one as a transpose without actually
> > :    doing the transpose.
> >
> > :    Below is a technique that allows one to write it as one normally
> > :    sees it written, but lets the Ada compiler do the selection of
> > :    an appropriate routine.
> >
> > : Is there a name for this technique?   Does it appear already
documented
> > : somewhere?
> >
> >
: --------------------------------------------------------------------------
----
> >
> > : --  ...
> >
> > : type Matrix is array (positive range <>, positive range <>) of Float;
> > : type Transpose is new Matrix;
> >
> > : --  ...
> >
> > : -- This is just a matrix multiply routine.
> > : function "*" (Left : Matrix; Right : Matrix) return Matrix;
> >
> > : -- This routine multiplies the transpose of Left by Right.
> > : function "*" (Left : Transpose; Right : Matrix) return Matrix;
> >
> > : ----------
> >
> > : --  Examples:
> > : A, B, C, D, E: Matrix;
> >
> > : --  ...
> >
> > : A := B * C;              --  Matrix multiply.
> > : D := Transpose (E) * F;  --  D gets the result of multiplying E'F
> > :                          --  (By selecting the appropriate routine.
> >
> > : ---------------------------------------------------------------------

Re: Looking for Ada Technique Name and References

[Gautier]

Hi. The point with what you are trying to do is that the "*"
cannot know if its argument is transposed by nature...
unless you create a sort of matrices that are taken
as transposed! But it doesn't solve your pb.
The thing to do is "function Mult_transposed_by(..."
as suggested. No ambiguity... NB: For small matrices (3x3)
it's not so dramatic explicitely to transpose - since
you chose the functional writing that's is already a bit more expensive.
The real cost is with the multiplications. Transposing
is not too awful - no fp arithmetic and well cached. E.g.
I fill sparse matrices with tiny 4x4 up to 27x27 matrices
involved in expressions like 
 Transpose(Me4) + Transpose(Me3) + Re + Transpose(Me)
and the filling is very fast (DEC Ada on OpenVMS).

-- 
Gautier

_____\\________________\_______\
http://members.xoom.com/gdemont/

Re: Looking for Ada Technique Name and References

[Vladimir Olensky]

 John Halleck <nahaj@u.cc.utah.edu> wrote in message
 news:88kh6q$j4j$1@coward.ks.cc.utah.edu...
 > > John Halleck (nahaj@u.cc.utah.edu) wrote:
 > > : I would appreciate it if someone could give me the name and a
 > > : print reference for the following technique.
 >
 >> Someone Replied:
 >>  It is called overloading.
 >

 >   It uses overloading, but that was not the technique I was trying

 >   to get accross.
 >
 >   The technique in question is turning the what is normally written
 >   as two function calls  (More or less:)
 >       "*" (Transpose (A), B)
 >   into a type mark and a single function call to a special function

>   that can handle it all more effeciently.


As a matter of fact the answer is contained in your original question.

Actually this is combination of two basic techniques and as such I do
not think that it has or should have any special name.  There would be
just not enough names to cover all possible combination of language
basic techniques.

In this case it is combination of object type marking (or view conversion
or type cast  - there are several terns for that )  with procedure
overloading.
Such view  conversion  in  some other systems  called simply as
"object logical view "  and this object is treated differently depending on
it's  current  logical view.

You have an matrix object and you mark it as transpose so that language
can choose appropriate  procedure  to handle matrix object  according
to it's  current view (or mark) .

In real life many things are done the same way but this happens without
paying special attention to that.


Regards,
Vladimir Olensky

Re: Looking for Ada Technique Name and References

[tmoran]

> type Transpose is new Matrix;
> D := Transpose (E) * F;  --  D gets the result of multiplying E'F
  Perhaps there's a term for it among magicians.  You get the audience's
attention focused on what you seem to be doing to E, and they don't
notice that you're actually doing something to '*' instead.  Is this
for an obfuscated code contest?

Re: Looking for Ada Technique Name and References

[David Starner]

On Tue, 22 Feb 2000 08:05:50 GMT, tmoran@bix.com <tmoran@bix.com> wrote:
>> type Transpose is new Matrix;
>> D := Transpose (E) * F;  --  D gets the result of multiplying E'F
>  Perhaps there's a term for it among magicians.  You get the audience's
>attention focused on what you seem to be doing to E, and they don't
>notice that you're actually doing something to '*' instead.  Is this
>for an obfuscated code contest?

Why is this obfuscated? It does Transpose (E) * F. The * operator does
multiplication.  Transpose does invert the array, it just does so by
redefining it instead of moving stuff around in memory. It's not the
clearest thing in the world, but it's entirely reasonable, especially
for the optimization done.

-- 
David Starner - dstarner98@aasaa.ofe.org
Only a nerd would worry about wrong parentheses with
square brackets. But that's what mathematicians are.
   -- Dr. Burchard, math professor at OSU

Re: Looking for Ada Technique Name and References

[Jon S Anthony]

Nick Roberts wrote:
> 
> "John Halleck" <nahaj@u.cc.utah.edu> wrote in message
> news:88svc0$nkj$1@coward.ks.cc.utah.edu...
> > ...
> > This trick is *** NOT *** supported by most languages.
>
> I don't think I've ever encountered any language that allows a
> function composition itself to be specially defined.

Any language that directly supports higher order functions supports
such definitions (any functional language, e.g., Common Lisp or Scheme).


> A classic case is where a 'mod' is done between two operands just
> after (or before) a divide is done between the same operands. Many
> compilers will optimise this into a single machine instruction
> (which computes both the quotient and the modulus in one go).

What has this to do with function composition?  Sounds like a typical
optimization arising out of data flow analysis.

/Jon

-- 
Jon Anthony
Synquiry Technologies, Ltd. Belmont, MA 02478, 617.484.3383
"Nightmares - Ha!  The way my life's been going lately,
 Who'd notice?"  -- Londo Mollari

Re: Looking for Ada Technique Name and References

[John Halleck]

Diana Webster (dkweb@arlut.utexas.edu) wrote:
: This technique is called "composition" in mathematics, i.e., the composition
: of two functions,
: i.e, sum (average (xnum)).  Most programming languages support this.

  The trick posted is not a composition of functions.

  It keeps the notation of the composition of functions, but substitutes
  a special purpose routine faster than the composition of functions. 

  This trick is *** NOT *** supported by most languages.

: John Halleck <nahaj@u.cc.utah.edu> wrote in message
: news:88kh6q$j4j$1@coward.ks.cc.utah.edu...
: > > John Halleck (nahaj@u.cc.utah.edu) wrote:
: > > : I would appreciate it if someone could give me the name and a
: > > : print reference for the following technique.
: >
: > > Someone Replied:
: >
: > >  It is called overloading.
: >
: >   It uses overloading, but that was not the technique I was trying
: >   to get accross.
: >
: >   The technique in question is turning the what is normally written
: >   as two function calls  (More or less:)
: >       "*" (Transpose (A), B)
: >   into a type mark and a single function call to a special function
: >   that can handle it all more effeciently.
: >
: > >
: > > : Background:
: > >
: > > :    Many matrix methods are written in the form  A := Transpose(B)*C
: > > :    But, actually forming the transpose is expensive, and you are
: better
: > > :    off just writing a second matrix multiply routine that takes the
: > > :    two matrices and treats the one as a transpose without actually
: > > :    doing the transpose.
: > >
: > > :    Below is a technique that allows one to write it as one normally
: > > :    sees it written, but lets the Ada compiler do the selection of
: > > :    an appropriate routine.
: > >
: > > : Is there a name for this technique?   Does it appear already
: documented
: > > : somewhere?
: > >
: > >
: : --------------------------------------------------------------------------
: ----
: > >
: > > : --  ...
: > >
: > > : type Matrix is array (positive range <>, positive range <>) of Float;
: > > : type Transpose is new Matrix;
: > >
: > > : --  ...
: > >
: > > : -- This is just a matrix multiply routine.
: > > : function "*" (Left : Matrix; Right : Matrix) return Matrix;
: > >
: > > : -- This routine multiplies the transpose of Left by Right.
: > > : function "*" (Left : Transpose; Right : Matrix) return Matrix;
: > >
: > > : ----------
: > >
: > > : --  Examples:
: > > : A, B, C, D, E: Matrix;
: > >
: > > : --  ...
: > >
: > > : A := B * C;              --  Matrix multiply.
: > > : D := Transpose (E) * F;  --  D gets the result of multiplying E'F
: > > :                          --  (By selecting the appropriate routine.
: > >
: > > : ---------------------------------------------------------------------

Re: Looking for Ada Technique Name and References

[John Halleck]

:  >   The technique in question is turning the what is normally written
:  >   as two function calls  (More or less:)
:  >       "*" (Transpose (A), B)
:  >   into a type mark and a single function call to a special function
:  >   that can handle it all more effeciently.


: [...]

: In this case it is combination of object type marking (or view conversion
: or type cast  - there are several terns for that )  with procedure
: overloading.
: Such view  conversion  in  some other systems  called simply as
: "object logical view "  and this object is treated differently depending on
: it's  current  logical view.

: You have an matrix object and you mark it as transpose so that language
: can choose appropriate  procedure  to handle matrix object  according
: to it's  current view (or mark) .

  Thank you...   You've given the best response to date, and you clearly
  understand what is intended.

: In real life many things are done the same way but this happens without
: paying special attention to that.

  The reason for the original question is a matter of documentation.
  It helps (in my opinion) if one has other places one can point
  people if you use an unfamiliar technique.

: Regards,
: Vladimir Olensky

  Thank you for your thoughtfull post.

Re: Looking for Ada Technique Name and References

[Nick Roberts]

"John Halleck" <nahaj@u.cc.utah.edu> wrote in message
news:88svc0$nkj$1@coward.ks.cc.utah.edu...
> ...
> This trick is *** NOT *** supported by most languages.

I don't think I've ever encountered any language that allows a function
composition itself to be specially defined. The nearest thing is when
compilers do optimisations.

A classic case is where a 'mod' is done between two operands just after (or
before) a divide is done between the same operands. Many compilers will
optimise this into a single machine instruction (which computes both the
quotient and the modulus in one go).

--
Nick Roberts
http://www.adapower.com/lab/adaos

Re: Looking for Ada Technique Name and References

[tmoran]

>Why is this obfuscated? It does Transpose (E) * F. The * operator does
>multiplication.  Transpose does invert the array, it just does so by
>redefining it instead of moving stuff around in memory. It's not the
  Transpose does not invert the array.  It tells the compiler to use a
different definition of "*".
  Suppose the body of the Matrix."*" routine was re-written, say to take
advantage of new vector arithmetic hardware or to fix an error.
"Transpose (E) * F" would be no faster, and no more correct, since it
actually calls a different "*" function entirely.
  It looks like "Transpose" is doing something to E, but instead it's
modifying "*".  Granted this seems like a useful little white lie,
but tricky code makes me uncomfortable.  The usual recommendation for
tricky, but useful, code is to comment thoroughly.  But compare
X := Transpose(E) * F; -- use the Transpose_Left_And_Multiply function
to
X := TLM(E, F); -- X := Transpose(E) * F;

  Of course if you are trying to save the time of copying an array,
you surely will use procedures, rather than array-returning functions,
anyway.

Re: Looking for Ada Technique Name and References

[Charles D. Hixson]

Jon S Anthony wrote:
  -- snip

> Any language that directly supports higher order functions supports
> such definitions (any functional language, e.g., Common Lisp or Scheme).
>
>

  -- snip

> /Jon
>
> --
> Jon Anthony
> Synquiry Technologies, Ltd. Belmont, MA 02478, 617.484.3383
> "Nightmares - Ha!  The way my life's been going lately,
>  Who'd notice?"  -- Londo Mollari

Also some not-so-functional languages, like Python, have constructs that
support this.  And since C supports pointers to functions, I suppose that
one could implement it in C.  And speaking of pointers to functions,
doesn't Ada95 ...

Re: Looking for Ada Technique Name and References

[Jon S Anthony]

> And since C supports pointers to functions, I suppose that
> one could implement it in C.  And speaking of pointers to functions,
> doesn't Ada95 ...

Depends on what you mean.  In any of these you need to hack a lot
of support - to make it really "right" you probably end up
hacking a lot of the implementation of some functional language.

In particular, none of the above supports closures (to have closures
you really need GC) and certainly not Lisp like macros (where you
can make compile time versions of such compositions).

/Jon

-- 
Jon Anthony
Synquiry Technologies, Ltd. Belmont, MA 02478, 617.484.3383
"Nightmares - Ha!  The way my life's been going lately,
 Who'd notice?"  -- Londo Mollari

Re: Looking for Ada Technique Name and References

[Jon S Anthony]

Brian Rogoff wrote:
> 
> Well, the topic has really changed, but if you are going to rank languages
> based on their support for the functional programming paradigm, I'd give
> Ada a fairly significant edge over C and C++ since

Agreed.

> (1) Ada is lexically scoped

??? Surely you don't mean to imply that C/C++ are dynamically scoped?


> (2) Ada allows the use of nested subprograms as subprogram parameters to
>     generic instantiations, allowing the crude simulation of downward
>     funargs.

Agreed, but this is very crude indeed.


> In my experience, this captures some small amount of FP style directly
> which is awful in C and unpleasant in C++ (where you can overload "()"
> and explicitly pass local state rather than directly referencing variables
> from an enclosing scope).

I'm still not clear on why you think this means that C/C++ are not
lexically
scoped (or perhaps "less lexically scoped" than Ada).  Certainly passing
local state around does not impact this.  I agree that there are cases
where
you _have_ to do this when a lexically scoped access is what you really
want.


>Re: On Tue, 29 Feb 2000, Charles Hixson wrote:
>> Even the various dialects of Lisp range from the purely functional (i.e.,
>> where all constructs can be phrased as a functional call with sugar around
>> it) to Common Lisp.  And none of these are what I now think of as the
>> functional languages:  ML, OCaML, etc.
>
> I don't want to start a FP language war in c.l.ada, but why do you
> consider "Pure Lisp", ML and OCaml functional, Common Lisp not? I use
> references, arrays, and exceptions in my OCaml code...

Good question; direct support for iteration?  Then again, he seems to
exclude
Scheme as well.  Shrug.

/Jon

-- 
Jon Anthony
Synquiry Technologies, Ltd. Belmont, MA 02478, 617.484.3383
"Nightmares - Ha!  The way my life's been going lately,
 Who'd notice?"  -- Londo Mollari

Re: Looking for Ada Technique Name and References

[Brian Rogoff]

On Tue, 29 Feb 2000, Jon S Anthony wrote:

> Brian Rogoff wrote:
> > 
> > Well, the topic has really changed, but if you are going to rank languages
> > based on their support for the functional programming paradigm, I'd give
> > Ada a fairly significant edge over C and C++ since
> 
> Agreed.
> 
> > (1) Ada is lexically scoped
> 
> ??? Surely you don't mean to imply that C/C++ are dynamically scoped?

No, C is lexically scoped too, but in a very trivial way, since you can't 
nest subprogram definitions. For those who aren't familiar with the
terminology, I mean that free variables in a block get their values from
the closest *textually* enclosing block, as opposed to getting its value 
from the runtime context like Emacs Lisp for example. 

Thanks for the prompt; what I wrote could easily mislead someone. Perhaps 
more precise terminology is called for. Or perhaps not, maybe I should
just have used a strong "and", the combination of lexical scope AND
subprogram nesting is what enables a limited FP style in Ada...

> > (2) Ada allows the use of nested subprograms as subprogram parameters to
> >     generic instantiations, allowing the crude simulation of downward
> >     funargs.
> 
> Agreed, but this is very crude indeed.

Yes, that's why I think it should be fixed. Generics are a heavyweight
mechanism for this, and there are a few cases (I posted one a long time 
ago based on some code Richard O'Keefe posted here) where using generics
is far less readable and reusable than something like Unrestricted_Access.

> > In my experience, this captures some small amount of FP style directly
> > which is awful in C and unpleasant in C++ (where you can overload "()"
> > and explicitly pass local state rather than directly referencing variables
> > from an enclosing scope).
> 
> I'm still not clear on why you think this means that C/C++ are not
> lexically
> scoped (or perhaps "less lexically scoped" than Ada).  Certainly passing
> local state around does not impact this.  I agree that there are cases
> where
> you _have_ to do this when a lexically scoped access is what you really
> want.

Because in Ada I can declare a subprogram nested in another, which refers
to local variables in the enclosing subprogram, and then use the nested 
subprogram as a parameter to a generic instantiation. I can't do that in 
C or C++, and to achieve the same effect I have to manually "lambda lift", 
and explicitly pass those local vars I'm interested in as method
arguments.

So, while they are strictly speaking lexically scoped, it isn't very
useful from a "coding FP" perspective. I hope that's clearer.

> 
> >Re: On Tue, 29 Feb 2000, Charles Hixson wrote:
> >> Even the various dialects of Lisp range from the purely functional (i.e.,
> >> where all constructs can be phrased as a functional call with sugar around
> >> it) to Common Lisp.  And none of these are what I now think of as the
> >> functional languages:  ML, OCaML, etc.
> >
> > I don't want to start a FP language war in c.l.ada, but why do you
> > consider "Pure Lisp", ML and OCaml functional, Common Lisp not? I use
> > references, arrays, and exceptions in my OCaml code...
> 
> Good question; direct support for iteration?  

Here's some legal OCaml from the manual

#let insertion_sort a =
   for i = 1 to Array.length a - 1 do
     let val_i = a.(i) in
     let j = ref i in
     while !j > 0 && val_i < a.(!j - 1) do
       a.(!j) <- a.(!j - 1);
       j := !j - 1
     done;
     a.(!j) <- val_i
   done;;

val insertion_sort : 'a array -> unit = <fun>

I guess OCaml isn't an FP then. Charles?

-- Brian

Re: Looking for Ada Technique Name and References

[Jon S Anthony]

Brian Rogoff wrote:
> 
> > ??? Surely you don't mean to imply that C/C++ are dynamically scoped?
> 
> No, C is lexically scoped too, but in a very trivial way, since you can't
> nest subprogram definitions.

Right - this is leading where I figured you intended it to go.

> > I'm still not clear on why you think this means that C/C++ are not
> > lexically scoped (or perhaps "less lexically scoped" than Ada).
> > Certainly passing local state around does not impact this.  I agree
> > that there are cases where you _have_ to do this when a lexically
> > scoped access is what you really want.
> 
> Because in Ada I can declare a subprogram nested in another, which
> refers to local variables in the enclosing subprogram, and then use
...

Right, this is actually exactly what I thought you intended.  I agree
with this completely.

> So, while they are strictly speaking lexically scoped, it isn't very
> useful from a "coding FP" perspective. I hope that's clearer.

Also agree.

> > > I don't want to start a FP language war in c.l.ada, but why do you
> > > consider "Pure Lisp", ML and OCaml functional, Common Lisp not? I use
> > > references, arrays, and exceptions in my OCaml code...
> >
> > Good question; direct support for iteration?
> 
> Here's some legal OCaml from the manual
> 
> #let insertion_sort a =
>    for i = 1 to Array.length a - 1 do
>      let val_i = a.(i) in
>      let j = ref i in
>      while !j > 0 && val_i < a.(!j - 1) do
>        a.(!j) <- a.(!j - 1);
>        j := !j - 1
>      done;
>      a.(!j) <- val_i
>    done;;

So much for iteration being the reason (as I mentioned, this couldn't
have been quite right anyway as he seems to exclude Scheme as well).

> val insertion_sort : 'a array -> unit = <fun>
> 
> I guess OCaml isn't an FP then. Charles?

Well, he already claimed it was, so there must be some other
feature(s) of direct Lisp family members that excludes them in his
taxonomy.  I see OCaml also has assignment.

Charles, what about Dylan?


/Jon

-- 
Jon Anthony
Synquiry Technologies, Ltd. Belmont, MA 02478, 617.484.3383
"Nightmares - Ha!  The way my life's been going lately,
 Who'd notice?"  -- Londo Mollari

Re: Looking for Ada Technique Name and References

[Charles Hixson]

Sorry, my point was that there was a "hierarchy" of languages.  I was
ranking them (approximately) by decreasing amount of support for
functional constructs. (Not clear, I realize, as I only gave three
examples, and C [or C++] really is about on a par with Ada.)  But there
are several different languages that give different degrees of support.
Even the various dialects of Lisp range from the purely functional (i.e.,
where all constructs can be phrased as a functional call with sugar around
it) to Common Lisp.  And none of these are what I now think of as the
functional languages:  ML, OCaML, etc.

Jon S Anthony wrote:

> > And since C supports pointers to functions, I suppose that
> > one could implement it in C.  And speaking of pointers to functions,
> > doesn't Ada95 ...
>
> Depends on what you mean.  In any of these you need to hack a lot
> of support - to make it really "right" you probably end up
> hacking a lot of the implementation of some functional language.
>
> In particular, none of the above supports closures (to have closures
> you really need GC) and certainly not Lisp like macros (where you
> can make compile time versions of such compositions).
>
> /Jon
>
> --
> Jon Anthony
> Synquiry Technologies, Ltd. Belmont, MA 02478, 617.484.3383
> "Nightmares - Ha!  The way my life's been going lately,
>  Who'd notice?"  -- Londo Mollari

Re: Looking for Ada Technique Name and References

[Brian Rogoff]

On Tue, 29 Feb 2000, Charles Hixson wrote:
> Sorry, my point was that there was a "hierarchy" of languages.  I was
> ranking them (approximately) by decreasing amount of support for
> functional constructs. (Not clear, I realize, as I only gave three
> examples, and C [or C++] really is about on a par with Ada.)  But there
> are several different languages that give different degrees of support.
> Even the various dialects of Lisp range from the purely functional (i.e.,
> where all constructs can be phrased as a functional call with sugar around
> it) to Common Lisp.  And none of these are what I now think of as the
> functional languages:  ML, OCaML, etc.

Well, the topic has really changed, but if you are going to rank languages 
based on their support for the functional programming paradigm, I'd give 
Ada a fairly significant edge over C and C++ since 

(1) Ada is lexically scoped
(2) Ada allows the use of nested subprograms as subprogram parameters to 
    generic instantiations, allowing the crude simulation of downward 
    funargs. 

In my experience, this captures some small amount of FP style directly
which is awful in C and unpleasant in C++ (where you can overload "()" 
and explicitly pass local state rather than directly referencing variables 
from an enclosing scope). I hope that the issue of downward funargs is 
revisited in Ada 0X, since using generics this way is awkward when you've 
grown accustomed to direct support for this. Robert Eachus mentioned that 
if you have "apply" you never need iterators. I think that's a bit extreme 
(and he really meant "fold" ;-) but I also think downward funargs would
make that programming style far nicer in Ada.

I don't want to start a FP language war in c.l.ada, but why do you
consider "Pure Lisp", ML and OCaml functional, Common Lisp not? I use 
references, arrays, and exceptions in my OCaml code...

-- Brian

Re: Looking for Ada Technique Name and References

[Wes Groleau]

> Well, the topic has really changed, but if you are going to rank languages
> based on their support for the functional programming paradigm, I'd give
> Ada a fairly significant edge over C and C++ .....

I once saw an example where someone (who obviously 
misunderstood the "mandate") wrote an Ada 83 package 
containing (I'm probably getting some of this wrong 
due to elapsed time):

  - an enumerated type where the literals were
    LISP predefined function names.

  - an unconstrained array type of those enums

  - Various support subprograms (I forget the
    details) that took the array type as parameter.

  - A subprogram that iterates over an enum array
    object and uses each element as a case selector.

Then this guy wrote his whole program in LISP, and 
with a trivial syntax transformation, could compile 
it with an Ada compiler and run it:

with LISP_Support; use LISP_Support;
procedure Main is

begin

   LISP(( CAR (( CDR (( atom, atom, atom )) .....
      ..... ));

   -- I don't know LISP, so I made up the above
   -- just to give the flavor....

end Main;

If anyone else saw this, and can tell me where to find
it, I'd love to see it again!  :-)

-- 
Wes Groleau
http://freepages.genealogy.rootsweb.com/~wgroleau

Re: Looking for Ada Technique Name and References

[Gautier]

Wes:

>    LISP(( CAR (( CDR (( atom, atom, atom )) .....
[...]

> If anyone else saw this, and can tell me where to find
> it, I'd love to see it again!  :-)

Anyway, CAR x could be programmed +/- as ( 1=> x(x'first) )
and CDR x as ( x(x'first+1 .. x'last) ), couldn't it ?

G.

Re: Looking for Ada Technique Name and References

[Jon S Anthony]

> Brian Rogoff wrote:
>
> On Tue, 29 Feb 2000, Jon S Anthony wrote:
> > Brian Rogoff wrote:
> > > I guess OCaml isn't an FP then. Charles?
> > 
> > Well, he already claimed it was, so there must be some other
> > feature(s) of direct Lisp family members that excludes them in his
> > taxonomy.  I see OCaml also has assignment.
> 
> Yes. OCaml and SML both have references, mutable arrays, and
> exceptions, which mean they are not "pure" FPs like Haskell and
> Clean, and much closer to languages like Scheme.

Sound closer to CL/CLOS to me (a lot of machinery "out-of-the-box").


> My view (grunt programmer in the trenches) is that we judge a
> language by its support for a particular style, and don't worry
> about pure/impure distinctions.

Here we are in great alignment.  I would go even further and say that
single paradigm languages (so called "pure" OO or FP or ...) are
always at a significant disadvantage in being able to cleanly express
solutions to problems.  Problems are nearly always multi-faceted and
larger ones are typically mult-perspective.  To cleanly tackle these
things you really need cleanly and flexibly handle diverse
representations and processing paradigms.


> Lisp (ANSI CL), Scheme and the MLs all support FP style *much*
> better than those languages without first class functions. To me,
> first class functions are the sine-qua-non of FP, so these are all
> FPLs.

Again, we are in close agreement.  Certainly first class functions are
_necessary_.  At the end of the day, I would say that the exclusion of
assignment yields "pure" FPLs.  Assignment is an ugly nasty thing, but
it's advantages always seem to out weigh this.


> Some might argue that Haskell and Clean do best of all because they
> are lazy (a little lie; really "non-strict") by default.

I think there are many who would argue this, where "best" means
"purest" not actually "overall goodness" (at least IMO).


> I don't have enough practical experience here, when I tried to use
> Haskell in anger I found it way too slow.

I too do not have enough real experience with Haskell, but all I have
read about it (even from its proponents) directly supports you here.


> Common Lisp and C++ are interesting in that they support "staged
> programming" or partial evaluation directly in the language, via
> procedural macros and templates respectively.

Common Lisp macros are really a _lot_ more than this - there's nothing
partial about them.  They go far beyond the sort of thing you can do
with templates.  A CL macro is really just another CL program and can
do anything a "regular" program can do.  It can make use of any
functions, methods, other macros, etc.  What makes them so potent is
that they are invoked between the reader and the parser (in this they
are sort of like a "typical macro").  But since you have the full
capabilities of CL here, you can perform "unlimited" compile time
computations.  In particular, on the input stream.  You can do truly
stunning things with this.  You could write a C++ compiler with it
(well, as close as one can write a C++ compiler...) or the goofy
template language of C++.

One of the most typical is to write a domain or application specific
language for use in the "real" programs you are after (so that you can
express things cleanly, flexibly and at very high level), have it
compile down into optimized CL/CLOS, and then have this passed off to
the optimizing CL compiler.  This all happens transparently.  Of
course, you can also do this sort of thing "on the fly".  Upshot: you
typically never need any interpreter for anything, and you can express
solutions that mirror the problem space extremely closely (far closer
than with simple OOP), and the result always has the full advantage of
optimized machine code.


> Kinda cool, but I understand the Ada position on these features and
> how they impact maintainability.

The C++ template crap might be "kinda cool", but the CL macro
capability is pretty awesome.  Done "correctly", CL macros have a very
_positive_ impact on maintainability.

I agree it can be useful to keep the Ada position in mind; certainly
in the C++ case, the Ada way is a hands down winner.  Note that in the
CL case, you can at any point of use of a macro immediately: 1) see
what it yields and check if this is what you expect, 2) try it to see
if the result does what you expect.  Typically neither of these is
necessary.


> As I understand it, the consensus in the Lisp community is that
> macros are to be used sparingly.

I would say - used correctly, sparingly not being relevant.


I suppose this has gone far enough afield from Ada and we can
pretty much lay it to rest in this forum.


/Jon

-- 
Jon Anthony
Synquiry Technologies, Ltd. Belmont, MA 02478, 617.484.3383
"Nightmares - Ha!  The way my life's been going lately,
 Who'd notice?"  -- Londo Mollari

Re: Looking for Ada Technique Name and References

[Wes Groleau]

Gautier wrote:
> 
> Wes:
> 
> >    LISP(( CAR (( CDR (( atom, atom, atom )) .....
> [...]
> 
> > If anyone else saw this, and can tell me where to find
> > it, I'd love to see it again!  :-)
> 
> Anyway, CAR x could be programmed +/- as ( 1=> x(x'first) )
> and CDR x as ( x(x'first+1 .. x'last) ), couldn't it ?

I'm not a LISP expert, but I think you're right.  However, the package
mentioned could do a lot more than CAR and CDR.

Re: Looking for Ada Technique Name and References

[Charles Hixson]

I'm not an expert, or even an intermediate at most of these languages, so if I
misclassified some of them, well, I'm sorry. My level of knowledge is such that
I class Scheme as a Lisp dialect that's simpler than Common Lisp, and don't go
much further.

What Do I Think Is a Functional Language?
When I was studying Lisp (around the time of Lisp 1.5 and without access to a
computer that actually had Lisp installed) there was a big argument raging as
to whether or not certain features should be included, because they converted
Lisp from being a purely functional language into being an impurely functional
language.  Most (all?) modern dialects have these features.  I don't remember
specifically what they were.  Something pretty basic.  Possibly fset or set.
Anything that does direct surgery on the list structure would have been
considered non-functional.  In a purely functional language there was to be no
direct changes allowed to anything that had been previously defined.  So this
is what I was considering one of the extreme poles.  Assembler (well,
micro-code [i.e., direct specification of hardware gate choices]) is, of
course, the other extreme pole along the spectrum that I was using.  I was not
assuming that anything "practical for use in large projects" would be found at
either pole (though I've heard arguments about that from both the camps that
this isn't true).

When I mentioned C or Ada as allowing functional programming to be done, my
idea was rather along the lines of "You can design a set of functions that are
complete and implement them in [C | Ada].  Then do your programming based on
those functions", rather than that the language as issued would support
functional programming (though both C and Ada *DO* prohibit changing the value
of parameters passed to a function).  Still, even using the assignment
statement directly voids the rules that I was taught functional programming
obeyed.

I am definitely the wrong person to be defending the functional position, as I
don't believe it to be ... desirable.  But then neither do I believe its
opposite to be desirable (necessary, perhaps).  I was merely observing that the
various languages fell along a range.  I'm sorry if I mispositioned one or two
of them.

Re: Looking for Ada Technique Name and References

[Brian Rogoff]

On Tue, 29 Feb 2000, Jon S Anthony wrote:
> Brian Rogoff wrote:
> > I guess OCaml isn't an FP then. Charles?
> 
> Well, he already claimed it was, so there must be some other
> feature(s) of direct Lisp family members that excludes them in his
> taxonomy.  I see OCaml also has assignment.

Yes. OCaml and SML both have references, mutable arrays, and exceptions, 
which mean they are not "pure" FPs like Haskell and Clean, and much closer 
to languages like Scheme. 

My view (grunt programmer in the trenches) is that we judge a language by
its support for a particular style, and don't worry about pure/impure
distinctions. 

So, IMO Ada supports the FP style better than C or C++, though Ada 83 
doesn't clearly do better since it doesn't have access to subprogram and 
has to always use generics whereas C can use function pointers. 

Lisp (ANSI CL), Scheme and the MLs all support FP style *much* better than 
those languages without first class functions. To me, first class
functions are the sine-qua-non of FP, so these are all FPLs. 

Some might argue that Haskell and Clean do best of all because they are
lazy (a little lie; really "non-strict") by default. I don't have enough 
practical experience here, when I tried to use Haskell in anger I found it
way too slow. 

I apply the same criteria to OOP, logic/relational style, etc. 

Common Lisp and C++ are interesting in that they support "staged programming" 
or partial evaluation directly in the language, via procedural macros and 
templates respectively. Kinda cool, but I understand the Ada position on
these features and how they impact maintainability. As I understand it,
the consensus in the Lisp community is that macros are to be used
sparingly. 

-- Brian

Re: Looking for Ada Technique Name and References

[Nick Roberts]

And Haskell (which is a bit bizarre).

--
Nick Roberts
http://www.adapower.com/lab/adaos

"Jon S Anthony" <jsa@synquiry.com> wrote in message
news:38BC3496.26FE@synquiry.com...

> Then again, he seems to exclude Scheme as well.  Shrug.