Re: Ada202X : Adding functors

["Peter C. Chapin" <pcc482719@gmail.com>]

On 11/15/2012 12:04 PM, Dmitry A. Kazakov wrote:

>> Could you elaborate on what you mean here? There are statically typed
>> functional languages where functions are first class and that also have
>> a reasonable notion of type safety.
>
> I think they are actually weakly typed.

In the functional language that I use the most (Scala) lambda terms are 
statically typed and fully checked at compile time, just like any other 
expression.

> Anyway, the issue is that functions are intimately related to the types of
> their arguments and results as primitive operations. Non-first class
> functions are singletons which ensures 1-1 mapping between the operation
> and the argument/result type. First-class functions would break that
> correspondence.

I guess I'm not understanding what you mean here.

> It is also unclear what happens with the operations defined on functional
> objects. What will be the types of function functions (functionals)? It is
> an infinite recursion of higher-order functions to stop somewhere.

If you have higher order functions then you will have a way to write 
function types. For example, in Scala:

def filter(someList: List[Int], predicate: Int => Boolean) = ...

This defines a function 'filter' that takes a list of integers and a 
function from Int to Boolean. The notation 'Int => Boolean' is a 
function type. And yes, you can write types like

	(Int => Boolean) => String

for functions taking a (function from Int to Boolean) and returning 
String. It's no big deal. After all you can use access to access types 
in Ada. You can use records containing records. If you want names for 
the intermediate types, create names for them:

	type PredicateType = Int => Boolean
	type PredicateProcessor = PredicateType => String

Peter