Opposto di mutare [chiuso]

Sto cercando un aggettivo; uno che descrive l'opposto di "mutare". Voglio usarlo per contrassegnare funzioni, metodi e parametri del metodo (incluso il ricevitore) come "non essere mutato" dalla funzione, simile a come fa il linguaggio D.

Ds funziona piuttosto bene per i parametri:

class X {
    void foo(const int x, immutable char[] y) {
        // x is readonly
        // y is readonly and can be trusted not to change
    }
}

Tuttavia, sia immutable che const sembrano brutti quando li si utilizza sulla funzione / metodo stesso per indicare che la funzione non modifica l'oggetto destinatario:

// again D
class X {
    private int x;

    void foo() const {
        // x becomes readonly because the method is marked s such
    }

    void foo2() immutable {
        // same as foo(): x is readonly
    }
}

Sto cercando una parola chiave con la stessa semantica delle parole chiave di cui sopra in D; ma come aggettivo da scrivere prima del nome della funzione:

class X {
    private x: int
    non-mutating foo() {
        // x is readonly
    }
}

Usando immutable si legge come se il metodo fosse immutabile (come finale in Java o non-Virtual in C # / C ++). Non posso usare la parola chiave dopo che la parentesi chiude l'elenco dei parametri perché questo è il posto dove dovrebbe andare il tipo di ritorno:

fun x() -> Int

Non sono completamente sicuro se questo è il posto giusto per porre questa domanda. Ma dal momento che non ho trovato un programming language design SE , ho capito che le persone che conoscono molti linguaggi di programmazione in questa community potrebbero darmi alcuni suggerimenti:)