Method chaining in Ada - oop

Question

So lots of languages have a pattern where you do something like this:
object = Create_Object().Set(1).Set(2).Set(3);
(I believe this originated in Smalltalk.) This works because the Set() method returns a reference to its receiver.
Can I do anything like this in Ada?
Approaches I've tried which don't work include:
-- doesn't work because the returned object is a read-only copy of the receiver
function Set(self: in out Object) return Object;
-- doesn't work because I can't return an access to a local variable
function Set(self: in out Object) return access Object;
-- looks like it works until I realise that it's not a method, and isn't doing
-- dynamic dispatch [*]
function Set(self: access Object) return access Object;
Can this be done?

Answer 1

I think a function with this profile will do the job for you:
function Set (Target : in Instance;
New_Item : in Integer) return Instance;
Having written a full package around that function declaration, I can write:
Object := Set (1).Set (2).Set (3);
Object.Show;
and get the output:
{1, 2, 3}
I've pushed the full sources to http://repositories.jacob-sparre.dk/miscellaneous-ada-2005-examples/.

Answer 2

Your third proposal is the correct approach, and you are in fact defining a primitive operation when you type "access" for the parameter. Here is an example, which uses two tagged types to show where dispatching occurs, and uses chaining of method calls. I have provided a procedure for convenience, as well, since otherwise you would have to use a temporary variable. I have used Create_Object, but an explicit call to "new", but that's of course the same thing. In addition, I have shown an example where Ada will not do dynamic dispatching when it knows statically the types involved. This is actually a nice features (performance-wise), even if indeed it requires care (and even experts are bitten every now and then :=)
with Utils; use Utils;
procedure Chain is
O : access Object := new Object;
C : access Child := new Child;
begin
O.Add (1).Add (2);
C.Add (3).Add (4);
end Chain;
package Utils is
type Object is tagged null record;
function Add (Self : access Object; Val : Integer) return access Object;
procedure Add (Self : access Object; Val : Integer); -- for convenience
type Child is new Object with null record;
overriding function Add (Self : access Child; Val : Integer) return access Child;
overriding procedure Add (Self : access Child; Val : Integer); -- for convenience
end Utils;
with Ada.Text_IO; use Ada.Text_IO;
package body Utils is
function Add (Self : access Object; Val : Integer) return access Object is
begin
Put_Line ("func Object.Add" & Val'Img);
Self.Add (Val); -- static call, not dynamic dispatch
return Self;
end Add;
procedure Add (Self : access Object; Val : Integer) is
begin
Put_Line ("proc Object.add" & Val'Img);
end Add;
overriding function Add (Self : access Child; Val : Integer) return access Child is
begin
Put_Line ("Child.Add" & Val'Img);
Self.Add (Val); -- static call, not dynamic dispatch
return Self;
end Add;
overriding procedure Add (Self : access Child; Val : Integer) is
begin
Put_Line ("proc Child.Add" & Val'Img);
end Add;
end Utils;
The output of this program is:
func Object.Add 1
proc Object.add 1
proc Object.add 2
Child.Add 3
proc Child.Add 3
proc Child.Add 4
Edit: As discussed in the comments, it is recommended to always use overriding to make sure the procedure is indeed overriding, not using a different profile. An access parameter does create a primitive operation.

Answer 3

From paragraph 18, function [formal] parameters can only use mode 'in' (read-only). So the input object does not get modified.
18 {parameter mode} The parameter mode of a formal parameter conveys the direction of information transfer with the actual parameter: in, in out, or out. Mode in is the default, and is the mode of a parameter defined by an access_definition. The formal parameters of a function, if any, shall have the mode in. [Ada 2005]
So I do not think that the language supports it as shown in other languages.
However, if you don't mind copies, we can save the result back in the object, but that's not the same as those other languages that you reference.
obj := obj.set("this").set(123).set(some_other_type);
You set "this" on a copy of 'obj' and return that copy. From that copy, we create a new copy and set 123 in that copy, which is in turn returned. Finally, that last result is copied and we set 'some_other_type' to it. That last copy is returned and we can save it in obj. Note that a well optimized implementation can avoid most if not all of those copies if the set() functions are small enough and inlined, but I would not could on it.
In retrospect, using procedures:
obj.set("this");
obj.set(123);
obj.set(some_other_type);
will do no copies at all.