एक वेक्टर

Question

पर मिलान जंग जंग पैटर्न tutorial पैटर्न मिलान के कुछ बहुत ही बुनियादी उदाहरण दिखाता है, जैसे एक सी-शैली स्विच स्टेटमेंट अनुकरण करने के लिए एक पूर्णांक से मिलान करना। ट्यूटोरियल यह भी दिखाता है कि कैसे एक ट्यूपल प्रकार, और संरचनाओं को नष्ट करने पर बुनियादी विनाश करना है।

ऐसा लगता है कि एक वेक्टर पर पैटर्न मिलान करना संभव होना चाहिए, लेकिन मैं इसके लिए सही वाक्यविन्यास नहीं समझ सकता और मुझे इसका कोई उदाहरण नहीं मिला है।

उदाहरण के लिए

, हास्केल में आप आसानी से एक सूची destructure कर सकते हैं:

fn foldr<A, B>(func: fn(A, B) -> B, 
       initValue: B, 
       vals: [A]) -> B { 
    alt vals { 
    [] { ret initValue; } 
    _ { 
     let h = vec::head(vals), 
      t = vec::tail(vals); 
     ret foldr(func, func(initValue, h), t); 
    } 
    } 
} 

नोट: करने के लिए सक्षम होने के लिए

foldr :: (a -> b -> b) -> b -> [a] -> b 
foldr func initValue []  = initValue 
foldr func initValue (x:xs) = func initValue $ foldr initValue func xs 

तो, एक किसी न किसी अनुवाद को देखते हुए, यह अच्छा होगा : मुझे पता है कि आप यहां एक कथन का उपयोग कर सकते हैं, मैं इसे एक वेक्टर पर मिलान पैटर्न के उदाहरण के रूप में उपयोग कर रहा हूं।

यह वर्तमान में प्रस्तुत करती है:

patterns.rs:10:4: 10:5 error: constant contains unimplemented expression type 
patterns.rs:10  [] { ret initValue; } 
       ^
error: aborting due to previous errors 

वहाँ संरचनाओं destructuring के लिए ट्यूटोरियल में एक उदाहरण है ({ .. } के साथ परिभाषित) और tuples ((..) साथ परिभाषित), तो ऐसा लगता है जैसे वहाँ में निर्मित किया जाना चाहिए समर्थन वैक्टरों के साथ-साथ विचार करने के लिए उनमें एक विशेष वाक्यविन्यास भी शामिल है ([ .. ] के साथ परिभाषित)।

अगर मैं गलत तरीके से वैक्टर का उपयोग कर रहा हूं तो मुझे सही करने के लिए स्वतंत्र महसूस करें।

Answer 1

काश मैं के बारे में अधिक सामान्य सलाह दे सकता है कैसे वैक्टर पर सबसे अच्छा उपयोग पैटर्न मिलान, लेकिन यहाँ आप उन्हें कैसे खाली वैक्टर के लिए परीक्षण करने के लिए उपयोग कर सकते हैं (कम से कम मुझे लगता है कि है कि क्या है कि हास्केल कोड कर रही है है करने के लिए .. ।):

use std; 
import std::io::println; 

fn main() { 
    let empty: [int] = []; 
    println(vec_alt(empty)); 
    println(vec_alt([1,2,3])); 
} 

fn vec_alt<A>(vals: [A]) -> str { 
    alt vals { 
     x if x == [] { "empty" } 
     _ { "otherwise" } 
    } 
} 

ध्यान दें कि कोशिश कर बस पारित करने के लिए [] के रूप में एक बहस में विफल रहता है क्योंकि संकलक वेक्टर के लिए एक प्रकार का अनुमान नहीं लगा सकता। ऐसा लगता है कि [()] (nil के अंदर एक वेक्टर) को पहले घोषित किए बिना, alt कथन का परीक्षण करने में असमर्थ लगता है कि हेड एक्सप्रेशन [()] से मेल खाता है (यह केवल डिफ़ॉल्ट पर आता है)।

सब कुछ, इस समय वेक्टर थोड़ा मोटा लगते हैं। यदि कुछ विशिष्ट उपयोग हैं तो आपको दिमाग में लगता है कि जंग का समर्थन नहीं होता है, डेवलपर्स सुझावों और आलोचनाओं के लिए खुले हैं: https://mail.mozilla.org/listinfo/rust-dev

एक और औपचारिक परिभाषा के लिए संदर्भ पुस्तिका भी देखें, और कुछ और उदाहरण चीजों को स्पष्ट करने में मदद करें: http://doc.rust-lang.org/doc/rust.html#alternative-expressions