सीक मॉड्यूल में कुछ फ़ंक्शन क्यों अनुकूलित किए गए हैं जबकि अन्य F # में नहीं थे?

Question

यह एक Seq मॉड्यूल के iter और map कार्यों बहुत धीमी Array और List मॉड्यूल समकक्ष की तुलना में किया जा रहा है के बारे में मेरे पिछले question अप करने के लिए का पालन करें।

स्रोत को देखते हुए, मैं देख सकता हूँ कि कुछ कार्यों ऐसे isEmpty और length के रूप में एक बहुत ही सरल प्रकार की जांच करता है IEnumerator का उपयोग कर का सहारा से पहले सरणियों और सूचियों के लिए अनुकूलन करने के लिए।

[<CompiledName("IsEmpty")>] 
let isEmpty (source : seq<'T>) = 
    checkNonNull "source" source 
    match source with 
    | :? ('T[]) as a -> a.Length = 0 
    | :? list<'T> as a -> a.IsEmpty 
    | :? ICollection<'T> as a -> a.Count = 0 
    | _ -> 
     use ie = source.GetEnumerator() 
     not (ie.MoveNext()) 

[<CompiledName("Length")>] 
let length (source : seq<'T>) = 
    checkNonNull "source" source 
    match source with 
    | :? ('T[]) as a -> a.Length 
    | :? ('T list) as a -> a.Length 
    | :? ICollection<'T> as a -> a.Count 
    | _ -> 
     use e = source.GetEnumerator() 
     let mutable state = 0 
     while e.MoveNext() do 
      state <- state + 1; 
     state 

iter एक ही दृष्टिकोण बेहद अपने प्रदर्शन में सुधार करने, जब मैं iter समारोह में यह अंतर्निहित संस्करण पर महत्वपूर्ण लाभ प्रस्तुत shadowed किया जा सकता है के मामले में:

[<CompiledName("Iterate")>] 
let iter f (source : seq<'T>) = 
    checkNonNull "source" source 
    use e = source.GetEnumerator() 
    while e.MoveNext() do 
     f e.Current; 

मेरे सवाल यह है कि Seq मॉड्यूल में कुछ कार्यों को विशिष्ट संग्रह प्रकारों (सरणी, सूची < टी> इत्यादि) के उपयोग के लिए अनुकूलित किया गया था। iter और nth जैसे अन्य फ़ंक्शन कैसे नहीं थे एक समान तरीके से समयबद्ध?

इसके अलावा, map फ़ंक्शन के मामले में, @mausch ने बताया, क्या Enumerable.Select (नीचे देखें) के समान दृष्टिकोण को नियोजित करना संभव नहीं है और विभिन्न संग्रह प्रकारों के लिए विशेष इटरेटर्स का निर्माण करना संभव नहीं है?

public static IEnumerable<TResult> Select<TSource, TResult>(this IEnumerable<TSource> source, Func<TSource, TResult> selector) 
    { 
     if (source == null) 
     throw Error.ArgumentNull("source"); 
     if (selector == null) 
     throw Error.ArgumentNull("selector"); 
     if (source is Enumerable.Iterator<TSource>) 
     return ((Enumerable.Iterator<TSource>) source).Select<TResult>(selector); 
     if (source is TSource[]) 
     return (IEnumerable<TResult>) new Enumerable.WhereSelectArrayIterator<TSource, TResult>((TSource[]) source, (Func<TSource, bool>) null, selector); 
     if (source is List<TSource>) 
     return (IEnumerable<TResult>) new Enumerable.WhereSelectListIterator<TSource, TResult>((List<TSource>) source, (Func<TSource, bool>) null, selector); 
     else 
     return (IEnumerable<TResult>) new Enumerable.WhereSelectEnumerableIterator<TSource, TResult>(source, (Func<TSource, bool>) null, selector); 
    } 

अग्रिम में बहुत धन्यवाद।

Answer 1

सतह पर, Seq.length/isEmpty में टाइप-चेक गलतियों की तरह लगते हैं। मुझे लगता है कि अधिकांश Seq फ़ंक्शन ऑर्थोगोनैलिटी के लिए ऐसे चेक नहीं करते हैं: List/Array मॉड्यूल में टाइप-विशिष्ट संस्करण पहले से मौजूद हैं। उन्हें डुप्लिकेट क्यों करें?

उन चेक LINQ में अधिक समझ में आता है क्योंकि यह केवल IEnumerable का उपयोग करता है।

Answer 2

आईटीईआर एक ही दृष्टिकोण के मामले में मुझे लगता है कि यह वह जगह है जहाँ अपने प्रश्न का उत्तर है बेहद इसके प्रदर्शन

सुधार करने के लिए किया जा सकता है। आपका परीक्षण कृत्रिम है, और वास्तव में इन विधियों के किसी वास्तविक दुनिया के उदाहरणों का परीक्षण नहीं करता है। ms में समय में मतभेद प्राप्त करने के लिए आपने इन विधियों के 10,000,000 पुनरावृत्तियों का परीक्षण किया।

आइटम की लागत प्रति वापस करने के लिए परिवर्तित, यहाँ वे हैं:

  Array List 
Seq.iter 4 ns 7 ns 
Seq.map 20 ns 91 ns 

इन विधियों आम तौर पर, एक बार संग्रह प्रति उपयोग किया जाता है इस लागत अर्थ अपने एल्गोरिदम प्रदर्शन के लिए एक अतिरिक्त रैखिक कारक है। सबसे बुरी स्थिति में आप सूची में 100 ns प्रति आइटम से कम खो रहे हैं (यदि आप प्रदर्शन के बारे में अधिक ख्याल रखते हैं तो आपको इसका उपयोग नहीं करना चाहिए)।

length के मामले में इसकी तुलना करें जो सामान्य मामले में हमेशा रैखिक होता है। इस अनुकूलन को जोड़कर आप किसी ऐसे व्यक्ति को भारी लाभ प्रदान करते हैं जो लंबाई को मैन्युअल रूप से कैश करना भूल जाता है लेकिन सौभाग्य से हमेशा एक सूची दी जाती है।

इसी तरह आप कई बार isEmpty पर कॉल कर सकते हैं, और एक और वस्तु निर्माण जोड़ना मूर्खतापूर्ण है अगर आप सीधे पूछ सकते हैं। (यह एक तर्क जितना मजबूत नहीं है)

ध्यान में रखना एक और बात यह है कि उन तरीकों में से कोई भी वास्तव में आउटपुट के एक से अधिक तत्वों को नहीं देखता है। आप निम्न कोड को क्या करना चाहते हैं (वाक्यविन्यास त्रुटियों या अनुपलब्ध विधियों को छोड़कर)

type Custom() = 
    interface IEnumerable with 
    member x.GetEnumerator() = 
     return seq { 
     yield 1 
     yield 2 
     } 
    interface IList with 
    member x.Item with 
     get(index) = index 
    member x.Count = 12 

let a = Custom() 
a |> Seq.iter (v -> printfn (v.ToString()))