Mutable parameters?

[osa1]

Can I update a function parameter? The only way I could find is copying the parameter to a var:

def runConsolePure(state: PureConsoleState) { prog: () => Unit / Console }: PureConsoleState = {
    var state = state;
    ...
}

Is there a shorthand for this?

[b-studios]

Hey, thanks for your question. No there is no shorthand. How would you imagine to look this like?

Typically, I also wouldn't "shadow" (use the same name), but call the parameter initialState or init and then have:

var state = initialState
...

I am saying this since I am not even sure whether this program would work in Effekt as written above :)

[osa1]

Thanks for the quick response!

How would you imagine to look this like?

Just as an example, Dart defines parameters as mutable by default, but allows making them immutable with final:

void mutableParameter(int i) {
  i += 1; // OK
}

void immutableParameter(final int i) {
  i += 1; // ERROR
}

In Effekt it could be the other way around: immutable by default, made mutable with var, e.g.

def runConsolePure(var state: PureConsoleState) { prog: () => Unit / Console }: PureConsoleState = {
    ...
}

I am saying this since I am not even sure whether this program would work in Effekt as written above :)

It seems to work, here's my full program:

import dequeue

record PureConsoleState(
    inputs: Dequeue[String],
    outputs: Dequeue[String]
)

def main() = {
    var inputs = emptyQueue[String]();
    inputs = inputs.pushBack("first line");
    inputs = inputs.pushBack("second line");

    var outputs = emptyQueue[String]();

    var consoleState = PureConsoleState(inputs, outputs);

    consoleState = runConsolePure(consoleState) { test() };

    println("Inputs: " ++ consoleState.inputs.show());
    println("Outputs: " ++ consoleState.outputs.show());
    ()
}

interface Console {
    def printLn(s: String): Unit
    def readLn(): String
}

def runConsolePure(state: PureConsoleState) { prog: () => Unit / Console }: PureConsoleState = {
    var state = state;
    try {
        prog()
    } with Console {
        def printLn(s) = {
            state = PureConsoleState(state.inputs, state.outputs.pushBack(s));
            resume(())
        }

        def readLn() = {
            state.inputs.popFront() match {
                case None() => () // TODO: How to panic here?
                case Some((input, inputsRest)) => {
                     state = PureConsoleState(inputsRest, state.outputs);
                     resume(input)
                }
            }
        }
    }
    state
}

def test(): Unit / Console = {
    do printLn("First output");
    do printLn("Second output");
    do readLn();
    do readLn();
    ()
}

[b-studios]

I understand that this might be desirable sometimes and it should indeed be possible to implement this as simple syntactic sugar (maybe already in the parser). In your concrete example, I would have expected to unwrap the inputs and outputs as local mutable vars and then package them back in the end:

def runConsolePure(state: PureConsoleState) { prog: () => Unit / Console }: PureConsoleState = {
    var inputs = state.inputs
    var outputs = state.outputs
    try {
        prog()
    } with Console {
        def printLn(s) = {
            outputs = outputs.pushBack(s)
            resume(())
        }

        def readLn() = {
            inputs.popFront() match {
                case None() => () // TODO: How to panic here?
                case Some((input, inputsRest)) => {
                  inputs = inputsRest
                  resume(input)
                }
            }
        }
    }
    PureConsoleState(inputs, outputs)
}

Regarding the // TODO: How to panic here?: Of course you could throw an exception:

raise(MissingValue(), "No value to read")

but the other option would be to rewrite the example to use push-pull streams and then wait until there is a value (since we already capture the continuation)

[b-studios]

For completeness, here is the full example using "bidirectional effects", that is operations (readLn) that have effects themselves:

Details

import dequeue

record PureConsoleState(
    inputs: Dequeue[String],
    outputs: Dequeue[String]
)

def main() = {
    with on[MissingValue].panic();

    var inputs = emptyQueue[String]();
    inputs = inputs.pushBack("first line");
    inputs = inputs.pushBack("second line");

    var outputs = emptyQueue[String]();

    var consoleState = PureConsoleState(inputs, outputs);

    consoleState = runConsolePure(consoleState) { test() };

    println("Inputs: " ++ consoleState.inputs.show());
    println("Outputs: " ++ consoleState.outputs.show());
    ()
}

interface Console {
    def printLn(s: String): Unit
    def readLn(): String / Exception[MissingValue]
}

def runConsolePure(state: PureConsoleState) { prog: () => Unit / Console }: PureConsoleState = {
    var state = state;
    try {
        prog()
    } with Console {
        def printLn(s) = {
            state = PureConsoleState(state.inputs, state.outputs.pushBack(s));
            resume(())
        }

        def readLn() = {
            state.inputs.popFront() match {
                case None() => resume { raise(MissingValue(), "No element to read from") }
                case Some((input, inputsRest)) => {
                     state = PureConsoleState(inputsRest, state.outputs);
                     resume { () => input }
                }
            }
        }
    }
    state
}

def test(): Unit / { Console, Exception[MissingValue] } = {
    do printLn("First output");
    do printLn("Second output");
    do readLn();
    do readLn();
    ()
}

[osa1]

Thanks for the code!

[jiribenes]

Hi, in addition to what was shown already, you can use the following to achieve something similar to mutable parameters:

1. global mutable references (Ref[T])

import ref

...

def runConsolePure(state: Ref[PureConsoleState]) { prog: () => Unit / Console }: Unit = {
    try {
        prog()
    } with Console {
        def printLn(s) = {
            state.set(PureConsoleState(state.get.inputs, state.get.outputs.pushBack(s)));
            resume(())
        }

        def readLn() = {
            state.get.inputs.popFront() match {
                case None() => () // TODO: How to panic here?
                case Some((input, inputsRest)) => {
                     state.set(PureConsoleState(inputsRest, state.get.outputs));
                     resume(input)
                }
            }
        }
    }
}

Complete code here

import dequeue
import ref

record PureConsoleState(
    inputs: Dequeue[String],
    outputs: Dequeue[String]
)

def main() = {
    var inputs = emptyQueue[String]();
    inputs = inputs.pushBack("first line");
    inputs = inputs.pushBack("second line");

    val outputs = emptyQueue[String]();

    val consoleState = ref(PureConsoleState(inputs, outputs));

    runConsolePure(consoleState) { test() };

    println("Inputs: " ++ consoleState.get.inputs.show());
    println("Outputs: " ++ consoleState.get.outputs.show());
    ()
}

interface Console {
    def printLn(s: String): Unit
    def readLn(): String
}

def runConsolePure(state: Ref[PureConsoleState]) { prog: () => Unit / Console }: Unit = {
    try {
        prog()
    } with Console {
        def printLn(s) = {
            state.set(PureConsoleState(state.get.inputs, state.get.outputs.pushBack(s)));
            resume(())
        }

        def readLn() = {
            state.get.inputs.popFront() match {
                case None() => () // TODO: How to panic here?
                case Some((input, inputsRest)) => {
                     state.set(PureConsoleState(inputsRest, state.get.outputs));
                     resume(input)
                }
            }
        }
    }
}

def test(): Unit / Console = {
    do printLn("First output");
    do printLn("Second output");
    do readLn();
    do readLn();
    ()
}

2. let runConsolePure reinterpret into some State effect:

interface State[St] {
  def getState(): St
  def setState(s: St): Unit
}

...

def runConsolePure { prog: () => Unit / Console }: Unit / State[PureConsoleState] = {
    try {
        prog()
    } with Console {
        def printLn(s) = {
            do setState(PureConsoleState(do getState().inputs, do getState().outputs.pushBack(s)));
            resume(())
        }

        def readLn() = {
            do getState().inputs.popFront() match {
                case None() => () // TODO: How to panic here?
                case Some((input, inputsRest)) => {
                     do setState(PureConsoleState(inputsRest, do getState().outputs));
                     resume(input)
                }
            }
        }
    }
}

Complete code here

import dequeue
import ref

interface State[St] {
  def getState(): St
  def setState(s: St): Unit
}

/// Handle the `State` effect using a `Ref` (global mutable reference)
// (but you could also handle it directly, there's no real reason for a `Ref` here anymore)
def statefully[R, St](r: Ref[St]) { prog: () => R / State[St] }: R =
  try { prog() } with State[St] {
    def getState() = resume(r.get())
    def setState(newState) = { r.set(newState); resume(()) }
  }

record PureConsoleState(
    inputs: Dequeue[String],
    outputs: Dequeue[String]
)

def main() = {
    var inputs = emptyQueue[String]();
    inputs = inputs.pushBack("first line");
    inputs = inputs.pushBack("second line");

    val outputs = emptyQueue[String]();

    val consoleState = ref(PureConsoleState(inputs, outputs));

    statefully(consoleState) { runConsolePure { test() } };

    println("Inputs: " ++ consoleState.get.inputs.show());
    println("Outputs: " ++ consoleState.get.outputs.show());
    ()
}

interface Console {
    def printLn(s: String): Unit
    def readLn(): String
}

def runConsolePure { prog: () => Unit / Console }: Unit / State[PureConsoleState] = {
    try {
        prog()
    } with Console {
        def printLn(s) = {
            do setState(PureConsoleState(do getState().inputs, do getState().outputs.pushBack(s)));
            resume(())
        }

        def readLn() = {
            do getState().inputs.popFront() match {
                case None() => () // TODO: How to panic here?
                case Some((input, inputsRest)) => {
                     do setState(PureConsoleState(inputsRest, do getState().outputs));
                     resume(input)
                }
            }
        }
    }
}

def test(): Unit / Console = {
    do printLn("First output");
    do printLn("Second output");
    do readLn();
    do readLn();
    ()
}

[osa1]

Thanks!