एलिक्सीर मामले में नियमित अभिव्यक्ति

Question

क्या आप एलिक्सिर में case के अंदर एक नियमित अभिव्यक्ति का उपयोग कर सकते हैं?

तो यह की तर्ज पर कुछ:

case some_string do 
    "string"  -> # do something 
    ~r/string[\d]+/ -> # do something 
    _    -> # do something 
end 

Answer 1

case के साथ यह संभव नहीं है, लेकिन आप उपयोग कर सकते हैं cond:

cond do 
    some_string == "string"      -> # do something 
    String.match?(some_string, ~r/string[\d]+/) -> # do something 
    true          -> # do something 
end 

कारण में हुक करने का कोई तरीका नहीं है कि वहाँ है विशिष्ट मानों के लिए विशेष कार्यों को कॉल करके मिलान पैटर्न। मुझे लगता है कि आपको रुबी से यह विचार मिला है, जो विशेष ऑपरेटर === को परिभाषित करके इसे लागू करता है। इसे रूबी के केस स्टेटमेंट द्वारा निहित रूप से बुलाया जाएगा और एक रेगेक्स के लिए यह दिए गए मूल्य से मेल खाएगा।

Answer 2

जैसा कि पैट्रिक ने अपने उत्तर में कहा था, इसके लिए कुछ भी अंतर्निहित नहीं है, और cond शायद आपका सबसे अच्छा विकल्प है।

लेकिन एक और विकल्प जोड़ने और एलिक्सीर की लचीलापन दिखाने के लिए: case एलीक्सिर में सिर्फ एक मैक्रो है, आप इसे करने के लिए regex_case जैसे अपने मैक्रो को कार्यान्वित कर सकते हैं।

आपको यह ध्यान रखना चाहिए कि इस परियोजना पर नए लोगों के लिए कोड को समझना मुश्किल हो सकता है, लेकिन यदि आप बहुत सारे रेगेक्स मिलान करते हैं, तो शायद व्यापार बंद हो सकता है। आप ही फैन्सला करें।

मैंने कुछ समय पहले implemented this, बस देखने के लिए कि यह संभव था:

defmodule RegexCase do 
    defmacro regex_case(string, do: lines) do 
    new_lines = Enum.map lines, fn ({:->, context, [[regex], result]}) -> 
     condition = quote do: String.match?(unquote(string), unquote(regex)) 
     {:->, context, [[condition], result]} 
    end 

    # Base case if nothing matches; "cond" complains otherwise. 
    base_case = quote do: (true -> nil) 
    new_lines = new_lines ++ base_case 

    quote do 
     cond do 
     unquote(new_lines) 
     end 
    end 
    end 
end 

defmodule Run do 
    import RegexCase 

    def run do 
    regex_case "hello" do 
     ~r/x/ -> IO.puts("matches x") 
     ~r/e/ -> IO.puts("matches e") 
     ~r/y/ -> IO.puts("matches y") 
    end 
    end 
end 

Run.run