Re: Ada202X : Adding functors

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

On 11/16/2012 03:59 AM, Dmitry A. Kazakov wrote:

>     type T is tagged ...
>     procedure Operation (X : T);
>
> There is only one instance of Operation for T. This is easy when Operation
> is not an object. Once you make it an object, there could possibly be more
> than one instance of.
>
>     X : T'Class;
> begin
>     X.Operation;  -- Which one instance is called here?

Isn't this an issue even without first class functions? It sounds like 
you are talking about dynamic dispatch... an OOP issue, not a functional 
issue. I guess I'm still not following you.

>> 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.
>
> Can I inherit it?

Yes.

class MyClass extends (Int => Boolean) => String {
   // ...
}

> Override it?

Not sure what you mean by this. You can override what it does when 
applied to an argument.

> Which are the classes of types
>
>     (Int => Boolean) => String
>
> operates on?

Scala treats function types as classes with a special 'apply' method. 
While that might seem like a circular definition it isn't because 
methods and functions are regarded differently in that language. In 
particular the type (Int => Boolean) => String is syntactic sugar for

	Function1[Function1[Int, Boolean], String]

where the [] syntax is used for generic type parameters. Anyway Scala 
has unusually tight integration between its functional and object 
oriented features (which is why I was surprised to learn that it didn't 
support contravariant refinement of parameter types). It's one of the 
hallmarks of that particular language.

Peter