Implementare un costrutto come Rusts 'match' in C?

Question

Implementare un costrutto come Rusts 'match' in C?

#1 da (4 voti)

4

Sto scrivendo un compilatore che compila in C, una cosa che sto tentando di fare è implementare un costrutto come la partita di Rust:

// { some function
    let mut foo = 32;
    match foo {
        3 => return "hey",
        4 | 5 | 6 => return "foo",
        9 ... 12 => return "blah",
        _ => return "bar",
    }
// }

Come apparirebbe un costrutto come questo nel codice C? Stavo pensando che una cosa semplice come questa potrebbe essere una costruzione di switch come questa:

switch (foo) {
    case 3: return "hey";
    case 4: case 5: case 6: return "foo";
    case 9: case 10: case 11: case 12: return "blah";
    default: return "bar";
}

E, soprattutto, come cercherebbe esempi più complicati come questo:

let pair = (0, -2);

match pair {
    (0, y) => println!("First is '0' and 'y' is '{:?}'", y),
    (x, 0) => println!("'x' is '{:?}' and last is '0'", x),
    _      => println!("It doesn't matter what they are"),
}

Dove la tupla è destrutturata e può gestire anche i valori?

code-generation compiler rust

posta Jon Flow 26.09.2016 - 18:17

fonte

1 risposta

Leggi altre domande sui tag code-generation compiler rust

Perché i miei programmi java girano più velocemente in eclissi che in BlueJ? Che cos'è uno schema di scrittura bufferizzato?

score 4 · Accepted Answer

Consideriamo un esempio di base super. La tua lingua ha solo due tipi, int e pair . Le coppie possono contenere altre coppie. Per i tuoi "casi", hai anche variabili non associate.

Quindi quando passi il valore da abbinare, puoi avere int o pair . Il modello da abbinare può essere un int , un pair o una variabile non associata. L'algoritmo di corrispondenza del modello quindi:

if my pattern is an int, and the input is an int, if they're equal, do this.
if my pattern is a var, assign the value to the var, and do this.
if my pattern is a pair, and the input is a pair, then if 
    pattern-match(pattern.first, value.first) && 
    pattern-match(pattern.second, value.second), do this.
otherwise, try the next pattern.

Per i Lisp di base, che hanno solo simboli e coppie, è tutto ciò di cui hanno bisogno. Per altre lingue, potrebbe essere necessario estendere le basi per gestire altri tipi e forse altre strutture.

E spero che tu possa vedere come questo diventa rischioso una volta che hai lo stato mutabile.