Allow marking functions as "input mutating"?

[yairm210]

Some functions change state - but only state that is passed to them as input

Example:

    fun addHelloWorld(list:MutableList<String>){
        list.add("Hello")
        list.add("World")
    }
    

    fun a(): MutableList<String> {
        val myList = mutableListOf<String>()
        addHelloWorld(myList)
        return myList
    }

A is obviously pure, even though it calls a function that changes state, because the change does not read or write any other external state, and the value passed in is local state - inaccessible from elsewhere.

This is important for performance reasons - the "readonly" version of the above is:

    fun getHelloWorld(): MutableList<String> {
        val list = mutableListOf<String>()
        list.add("Hello")
        list.add("World")
        return list
    }
    
    @Pure
    fun a(): MutableList<String> {
        val myList = mutableListOf<String>()
        myList.addAll(getHelloWorld())
        return myList
    }

where you pay allocation overhead for creating and destructing the extra list.

A third alternative that works, is passing in a lambda to do this for us:

    @Pure
    fun addHelloWorld(@Pure add: (String) -> Unit){
        add("Hello")
        add("World")
    }
    
    @Pure
    fun a(): MutableList<String> {
        val myList = mutableListOf<String>()
        addHelloWorld{myList.add(it)}
        return myList
    }

Why does this work?

• The lambda is checked for purity in a() - acceptable, since a is allowed to mutate myList
• When passing a @pure lambda, since the containing function is @pure the lambda is prechecked
• Within addHelloWorld it's a function invoke

But this is a very different way of working, and our purpose is to not have to force users to change their code in order to get good validation results!

Problems:

• Can't have just one marking - pure input mutators and readonly input mutators are different
  • an additional annotation, like @Pure @MutatesInput, kind of takes the meaning away from Pure
  • two annotations - @MutatesInputReadonly and @MutatesInputPure - feels bad
• Need to ensure that values passed are mutatable by the passing function

[paganaye]

I vote for

@NoCapture
fun addHelloWorld(@MutatesInput @NoCapture list: MutableList<String>) {
    list.add("Hello")
    list.add("World")
}

@Pure
fun a(): MutableList<String> {
    @Owned val myList = mutableListOf<String>() // fresh/owned
    addHelloWorld(myList) // allowed: MutatesInput + Owned and NoCapture
    return myList
}

As as I see it, it should be correct first. Then the plugin could check and infer some of the missing attributes at run time and mark them as warnings.

[yairm210]

@owned here is called @localstate - owned can imply "I own this but others have read access" whereas "this state is only available here" is a different concept :)

I'm not sure what you mean by "no capture" though, can you elaborate?