क्या एरलांग में बहु-अर्द्धता अज्ञात कार्य संभव हैं?

Question

मैं एक स्थिति है जहाँ मैं केवल अनाम प्रक्रियाएं कि एक चर के लिए आवंटित कर रहे हैं, बना सकते हैं इस तरह में हूँ:

Foo = fun(X) -> X end. 

मैं जानता हूँ कि अगर आप एक मॉड्यूल में आप कुछ इस तरह कर सकते हैं:

foo(X) -> X. 
foo(X, Y) -> X + Y. 
% i.e. foo(3) = 3, foo(3,4) = 7 

मेरे प्रश्न हैं: क्या यह अज्ञात कार्यों के साथ संभव है?

एक ब्लॉग पोस्ट (कि मैं अब माफी खो दिया है) आप कुछ इस तरह कर सकता है सोचने के लिए मुझे का नेतृत्व किया:

Foo = fun(X) -> X; 
     (X, Y) -> X + Y 
     end. 

लेकिन वह काम नहीं करता, जैसा कि मैंने एक "सिर बेमेल 'त्रुटि मिलती है ।

Answer 1

आप केवल पैटर्न मैच:

Foo = fun ([X]) -> X; 
      ([X,Y]) -> {X,Y} 
      end 

मैं भी उत्सुक प्रदर्शन को देखने के लिए नहीं था, इसलिए मैं बेंच मार्किंग का शीघ्रता से जाने के लिए किया था:

Foo = fun ({x,y}) -> one; 
      ({a,b}) -> two 
      end 

तुम सिर्फ एक सूची को स्वीकार कर सकता है यह। यह बिल्कुल सही नहीं है, और इसका इरादा केवल यह होना चाहिए कि वास्तव में क्या हो सकता है, और वास्तव में किसी को औसत, मानक विचलन, औसत, न्यूनतम और अधिकतम गणना करना चाहिए, लेकिन मैंने 1,000,000 कॉल करने के लिए न्यूनतम समय चुना।

-module(foo). 

-export([run/1, norm1/0, norm2/0, norm3/0, norm4/0, list1/0, list2/0, list3/0, list4/0]). 

-define(COUNT, 1000000). 


run(F) -> 
    T = lists:foldl(
     fun(_,Min) -> 
      T = ?MODULE:F(), 
      if T < Min -> T; true -> Min end 
      end, 
     ?MODULE:F(), 
     lists:seq(1,99) 
     ), 
    T 
    . 

norm1() -> 
    Foo = fun(N) -> N * N end, 
    {T,_} = timer:tc(fun() -> 
     lists:map(fun(A) -> Foo(A) end, lists:seq(1,?COUNT)) 
     end), 
    T 
    . 

norm2() -> 
    Foo = fun(N, M) -> N * M end, 
    {T,_} = timer:tc(fun() -> 
     lists:map(fun(A) -> Foo(A,A) end, lists:seq(1,?COUNT)) 
     end), 
    T 
    . 

norm3() -> 
    Foo = fun(M, N, M) -> N * M end, 
    {T,_} = timer:tc(fun() -> 
     lists:map(fun(A) -> Foo(A,A,A) end, lists:seq(1,?COUNT)) 
     end), 
    T 
    . 

norm4() -> 
    Foo = fun(N, M, N, M) -> N * M end, 
    {T,_} = timer:tc(fun() -> 
     lists:map(fun(A) -> Foo(A,A,A,A) end, lists:seq(1,?COUNT)) 
     end), 
    T 
    . 

list1() -> 
    Foo = fun([N]) -> N * N end, 
    {T,_} = timer:tc(fun() -> 
     lists:map(fun(A) -> Foo([A]) end, lists:seq(1,?COUNT)) 
     end), 
    T 
    . 

list2() -> 
    Foo = fun([N, M]) -> N * M end, 
    {T,_} = timer:tc(fun() -> 
     lists:map(fun(A) -> Foo([A,A]) end, lists:seq(1,?COUNT)) 
     end), 
    T 
    . 

list3() -> 
    Foo = fun([_, N, M]) -> N * M end, 
    {T,_} = timer:tc(fun() -> 
     lists:map(fun(A) -> Foo([A,A,A]) end, lists:seq(1,?COUNT)) 
     end), 
    T 
    . 

list4() -> 
    Foo = fun([_, _, N, M]) -> N * M end, 
    {T,_} = timer:tc(fun() -> 
     lists:map(fun(A) -> Foo([A,A,A,A]) end, lists:seq(1,?COUNT)) 
     end), 
    T 
    . 

यह परिणाम है::

मैं इस कोड का इस्तेमाल किया

1> foo:run(norm1). 
44820 
2> foo:run(norm2). 
48959 
3> foo:run(norm3). 
50328 
4> foo:run(norm4). 
50402 
5> 
5> foo:run(list1). 
50463 
6> foo:run(list2). 
58948 
7> foo:run(list3). 
60829 
8> foo:run(list4). 
86604 
9> 

प्रदर्शन जाहिर है, कितनी देर सूची है पर निर्भर करने के रूप में एक उम्मीद होती है, क्योंकि यह करने के लिए किया जा रहा है सूची के माध्यम से काम करते हैं, और जुर्माना एक सामान्य कॉल से अधिक है।

प्रदर्शन अंतर मेरे लिए इतना अच्छा नहीं लग रहा है कि कम से कम यदि आप सही सूचियों के बारे में चिंता करते हैं, तो कम से कम, यदि आपको अपनी सूचियों में बहुत अधिक तर्क होने की उम्मीद नहीं है!

Answer 2

सरल और सही उत्तर नहीं है, आप नहीं कर सकते हैं। यह वास्तव में के रूप में जब आप

foo(X) -> X. 
foo(X, Y) -> X + Y. 

कर आप वास्तव में दो कार्यों पैदा कर रहे काफी तार्किक है: foo/1, एक तर्क के एक समारोह; और foo/2, एक और फ़ंक्शन जिसमें दो तर्क हैं। वे समान foo हैं। यह सीधे अज्ञात कार्यों (funs) पर मानचित्र करता है, इसलिए आपको दो अलग-अलग मज़े, एक तर्क में से एक और दो तर्कों में से एक बनाना होगा।

"सिर विसंगति" त्रुटि विभिन्न तर्कों के बारे में शिकायत कर रही है।