एक रिकर्सिव क्लोजर लौटने के लिए फ़ंक्शन हस्ताक्षर

Question

मैं एक फ़ंक्शन को लागू करने का प्रयास कर रहा हूं जो एक रिकर्सिव क्लोजर देता है। हालांकि, मुझे यह सुनिश्चित नहीं है कि फ़ंक्शन हस्ताक्षर में इसे कैसे व्यक्त किया जाए। पाइथन

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') 

और जंग के लिए छद्म कोड में एक कार्य कार्यान्वयन का उदाहरण कोड यहां दिया गया है।

enum Msg { 
    Inc, 
    Dec 
} 

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

Answer 1

क्योंकि जंग पुनरावर्ती प्रकार का समर्थन करता है, तो आप सिर्फ एक अलग संरचना में प्रत्यावर्तन सांकेतिक शब्दों में बदलना करने की जरूरत है:

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); 
    } 
} 

हम यहाँ दुर्भाग्य से मुक्केबाजी के साथ भाग नहीं कर सकते, -, के बाद से अनबॉक्स्ड बंद unnameable प्रकार है हम संरचना घोषणा के अंदर उन्हें नाम देने में सक्षम होने के लिए उन्हें एक विशेषता वस्तु में बॉक्स करने की आवश्यकता है।