Funktionssignatur zum Zurückgeben eines rekursiven Abschlusses

Question

Ich versuche, eine Funktion zu implementieren, die einen rekursiven Abschluss zurückgibt, obwohl ich nicht sicher bin, wie das in der Funktionssignatur auszudrücken ist. Hier ist ein Beispielcode einer funktionierenden Implementierung in Python

def counter(state): 
    def handler(msg): 
     if msg == 'inc': 
      print state 
      return counter(state + 1) 

     if msg == 'dec': 
      print state 
      return counter(state - 1) 
    return handler 

c = counter(1) 
for x in range(1000000): 
    c = c('inc') 

und Pseudocode für Rust.

enum Msg { 
    Inc, 
    Dec 
} 

fn counter(state: Int) -> ? { 
    move |msg| match msg { 
     Msg::Inc => counter(state + 1), 
     Msg::Dec => counter(state - 1), 
    } 
} 

Answer 1

Because Rust rekursive Typen unterstützt, brauchen Sie nur die Rekursion in einer separaten Struktur zu kodieren:

enum Msg { 
    Inc, 
    Dec, 
} 

// in this particular example Fn(Msg) -> F should work as well 
struct F(Box<FnMut(Msg) -> F>); 

fn counter(state: i32) -> F { 
    F(Box::new(move |msg| match msg { 
     Msg::Inc => { 
      println!("{}", state); 
      counter(state + 1) 
     } 
     Msg::Dec => { 
      println!("{}", state); 
      counter(state - 1) 
     } 
    })) 
} 

fn main() { 
    let mut c = counter(1); 
    for _ in 0..1000 { 
     c = c.0(Msg::Inc); 
    } 
} 

Wir können nicht mit Boxen hier tun, weg, leider - da unboxed Verschlüsse unnameable Typen haben wir Sie müssen sie in ein Merkmalsobjekt einbetten, um sie in der Strukturdeklaration benennen zu können.