केस स्टेटमेंट्स और पैटर्न मिलान

Question

मैं एक असाइनमेंट के लिए एसएमएल में कोडिंग कर रहा हूं और मैंने कुछ अभ्यास समस्याएं की हैं और मुझे लगता है कि मुझे कुछ याद आ रहा है- मुझे लगता है कि मैं बहुत सारे case कथन का उपयोग कर रहा हूं। यहाँ मैं क्या कर रहा हूं और मैं क्या साथ .:

1. समस्या हो रही है के लिए समस्या बयान एक समारोह all_except_option है, जो एक स्ट्रिंग और स्ट्रिंग सूची लेता लिखें है। यदि स्ट्रिंग सूची में नहीं है, तो वापस लौटें, अन्यथा कुछ lst वापस करें जहां lst तर्क सूची की तरह है, सिवाय इसके कि स्ट्रिंग इसमें नहीं है।

   fun all_except_option(str : string, lst : string list) = 
       case lst of 
       [] => NONE 
       | x::xs => case same_string(x, str) of 
          true => SOME xs 
         | false => case all_except_option(str, xs) of 
             NONE => NONE 
            | SOME y=> SOME (x::y) 
   

2. एक समारोह get_substitutions1 है, जो एक स्ट्रिंग सूची सूची (तार, खिलाड़ी को बदलने की सूची की एक सूची) और एक स्ट्रिंग रों लेता है और एक स्ट्रिंग सूची लौटाती है लिखें। नतीजे में सभी स्ट्रिंग्स हैं जो प्रतिस्थापन में कुछ सूची में हैं, जिनके पास भी है, लेकिन परिणामस्वरूप स्वयं नहीं होना चाहिए।

   fun get_substitutions1(lst : string list list, s : string) = 
       case lst of 
       [] => [] 
       | x::xs => case all_except_option(s, x) of 
          NONE => get_substitutions1(xs, s) 
          | SOME y => y @ get_substitutions1(xs, s) 
   

- same_string एक प्रदान की समारोह, fun same_string(s1 : string, s2 : string) = s1 = s2

Answer 1

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

fun all_except_option (str, []) = NONE 
    | all_except_option (str, x :: xs) = 
    case same_string(x, str) of 
     true => SOME xs 
    | false => case all_except_option(str, xs) of 
       NONE => NONE 
       | SOME y => SOME (x::y) 

fun get_substitutions1 ([], s) = [] 
    | get_substitutions1 (x :: xs, s) = 
    case all_except_option(s, x) of 
     NONE => get_substitutions1(xs, s) 
    | SOME y => y @ get_substitutions1(xs, s) 

गति महत्व का नहीं है, तो आप पहले समारोह में दो मामलों मर्ज कर सकते हैं:

fun all_except_option (str, []) = NONE 
    | all_except_option (str, x :: xs) = 
    case (same_string(x, str), all_except_option(str, xs)) of 
     (true, _)  => SOME xs 
    | (false, NONE) => NONE 
    | (false, SOME y) => SOME (x::y) 

लेकिन चूंकि आप दूसरे फ़ंक्शन में एपेंड (@) का उपयोग कर रहे हैं, और चूंकि यह पूंछ रिकर्सिव नहीं है, मुझे विश्वास नहीं है कि यह आपकी प्रमुख चिंता है। ध्यान रखें कि परिशिष्ट संभावित "बुराई" है और आपको लगभग हमेशा सहवास (और का उपयोग करना चाहिए, फिर इसे वापस करने पर अपने परिणाम को उलट दें) और जब संभव हो तो पूंछ रिकर्सन (यह हमेशा होता है)।

तुम सच में स्पष्ट प्रकार एनोटेशन की तरह है, तो आप इसे इस तरह से कर सकता है:

val rec all_except_option : string * string list -> string list option = 
fn (str, []) => NONE 
    | (str, x :: xs) => 
    case (same_string(x, str), all_except_option(str, xs)) of 
     (true, _)  => SOME xs 
    | (false, NONE) => NONE 
    | (false, SOME y) => SOME (x::y) 


val rec get_substitutions1 : string list list * string -> string list = 
fn ([], s) => [] 
    | (x :: xs, s) => 
    case all_except_option(s, x) of 
     NONE => get_substitutions1(xs, s) 
    | SOME y => y @ get_substitutions1(xs, s) 

लेकिन वह बस अपना पसंदीदा तरीका है, अगर मैं वास्तव में टाइप टिप्पणियां जोड़ने के लिए है।

वैसे, पृथ्वी पर आपके पास same_string फ़ंक्शन क्यों है? आप इसके बजाय सीधे तुलना कर सकते हैं। एक सहायक फ़ंक्शन का उपयोग करना केवल विचलित है, जब तक कि आप किसी बिंदु पर इसे किसी विशेष तर्क के साथ विनिमय करने की योजना नहीं बनाते। हालांकि आपके फ़ंक्शन नाम उस पर जोर नहीं देते हैं। then - - else

Answer 2

Jesper.Reenberg क्या उल्लेख के अलावा, मैं सिर्फ इतना है कि true और false के लिए एक bool पर एक मैच के साथ एक if बदला जा सकता है उल्लेख करना चाहता था। हालांकि, कुछ लोग मानते हैं कि मामले के बयान के मुकाबले

Answer 3

fun same_string(s1: string, s2: string) = if String.compare(s1, s2) = EQUAL then true else false 


fun contains([], s: string) = false 
| contains(h::t, s: string) = if same_string(s, h) then true else contains(t, s) 


fun all_except_option_successfully(s: string, []) = [] 
| all_except_option_successfully(s: string, h::t) = if same_string(s, h) then t else (h :: all_except_option_successfully(s, t)) 


fun all_except_option(s: string, []) = NONE 
| all_except_option(s: string, h::t) = if same_string(s, h) then SOME t else if contains(t, s) then SOME (h :: all_except_option_successfully(s, t)) else NONE