Question

I’m going to preface this by saying that this is by no means a major issue, more of something I haven’t really heard talked about in terms of programming language design, and I was wondering if anyone had any interesting solutions.

The crux of the problem is this. Sometimes in an object-oriented language, I want to be able to modify an object via one of its methods, but return the object itself instead of what that method returns.

to give a java example:

class MyClass{
    public MyClass(List<Integer> list){
        //do constructor stuff
    }

    public MyClass(Integer i){
        //what I would like to be able to do
        this((new LinkedList<Integer>).add(i));
    }
}

I can’t create a temporary list in the second constructor, because this() must be the first line. Obviously there are a lot of ways to do this by changing the implementation, like creating an add() method that returns the object, making it the responsibility of the function constructing the object to make the list, etc.

But, considering a lot of the time you can’t/don’t want to modify or create a subclass (for LinkedList) and you might not want to muddy up the calling code, being able to modify and return an object in the style of ++x could be really useful. Something like
this(#(new LinkedList).add(i) to signify you want to object, not the method return. Does anyone know of a language that allows this is some concise syntactic way? If not, would this be useful at all or am I missing something fundamental here?

Answer 1

Wouldn’t this work?

public class MyClass{
    public MyClass(List<Integer> list){
        //do constructor stuff
    }

    public static MyClass create(Integer i) {
        List<Integer> list = new new LinkedList<Integer>();
        list.add(i);
        MyClass myClass = new MyClass(list);
        return myClass;
    }
}

This is somewhat common design pattern called Factory Pattern.