Re: Do people who use Ada also use ocaml or F#?

[Georg Bauhaus <rm-host.bauhaus@maps.futureapps.de>]

On 10/30/10 3:32 AM, Chad R. Meiners wrote:
>  In many cases, the repetition of type assertion is a
> desirable sanity check; however, ML-based languages allows for the
> functionally to be more efficiently expressed in some cases.  Take
> pattern matching and automatic generalization for an example
>
> let reduce foo =
>    let rec go carry = function
>      | [] ->  carry
>      | value :: tail ->  go (foo carry value) tail
>    in go

Interestingly, Guido van Rossum has let list comprehensions
into Python 3 but has reduced `reduce` in rank. He reminds
programmers that Python is a programming language and
that they should please use a for loop!  ;-)

Indeed, leaving currying (and fun?) aside, one wouldn't
necessarily want to pass ever new lists around:

generic
    type T is private;
    Zero : in T;
    with function Op (Left, Right: T) return T;
    type Index is (<>);
    with function Element (Position : Index) return T;
function Reduce (First, Last: Index) return T;

function Reduce (First, Last: Index) return T is
    Result : T;
begin
    Result := Zero;
    for K in First .. Last loop
       Result := Op (Result, Element(K));
    end loop;
    return Result;
end Reduce;

The odd thing is that the type of functions in functional
languages is essentially composite.  Whereas the idea of
a function is one thing!  Hence I'd expect it worth a type that
is not just a consequence of the type of arguments in the
function table's columns (such as 'a -> 'b -> 'a).  Is
functional abstraction not more than a cross product of data?

But I understand that mathematical paper writing suggest a formalism
for expressing ideas that is closer to the mathematical ideal of
not stating what is deemed obvious in the target group
(and acceptable, viz. expected and fashionable).   Alas,
results usually need to be re-worked into simply constructed
and memory-efficient programs for real computers.
Even when using a functional language...  :-)


-- Georg