क्या पाइपलाइनों की एक श्रृंखला को कार्यात्मक संरचना में परिवर्तित करने के लिए एक चरण-दर-चरण प्रक्रिया है?

Question

क्या कई पाइपलाइनों को कार्यात्मक संरचना में परिवर्तित करने के लिए एक चरण-दर-चरण प्रक्रिया है?

साइड नोट: मैं भी सही संदर्भ में शब्द "कार्यात्मक रचना" का उपयोग किया?

मैं निम्नलिखित कोड है:

let purchase qty inventory = 
    buyFrom inventory qty |> fromInventory 
          |> reduceBy qty 

मैं कार्यात्मक संरचना का समर्थन करने के लिए इस कोड refactor करना चाहता था।

तो मैंने सोचा कि मैं यह कर सकता है:

let purchase qty inventory = 
    buyFrom inventory >> fromInventory >> reduceBy qty 

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

यहाँ समारोह के लिए अपने परीक्षण है:

[<Test>] 
let ``buy last product``() = 
    [SomeProduct] |> purchase 1 
        |> should equal [] 

नोट:

मैं अभी भी एफपी बुनियादी बातों के साथ संघर्ष कर रहा हूँ और अभी भी में एक पाइप लाइन के कार्य प्रवाह परिवर्तित करने की प्रक्रिया समझ में नहीं आता एक कार्यात्मक संरचना।

मुझे लगता है कि मैं समझता हूं कि कार्यात्मक संरचना आंशिक अनुप्रयोग पर निर्भर करती है जो मुझे लगता है कि मेरे पास अब एक संभाल है। इस प्रकार, मेरे पास यह मानने का कारण है कि मेरे रिफैक्टर फ़ंक्शन में कोई तर्क नहीं है।

वर्कफ़्लो पर कोई मार्गदर्शन मैं कार्यात्मक संरचना में बेहतर होने के लिए उपयोग कर सकता हूं?

परिशिष्ट:

type Product = 
    | SomeProduct 

type TransactionResult = { Price:decimal; Inventory:Product list } 

(* Functions *) 

let priceOf qty product = 
    match product with 
    | SomeProduct -> match qty with 
        | 3 -> decimal (qty - 1) * 1.99m 
        | _ -> decimal (qty) * 1.99m 

let rec reduceBy count list = 
    match list with 
    | first::remaining when count = 1   -> remaining 
    | first::second::remaining when count > 1 -> second::remaining |> reduceBy (count - 1) 
    | remaining when count = 0    -> remaining 
    | _ -> [] 

let buyFrom inventory qty = 
    { Price=priceOf qty (List.head inventory); Inventory=inventory } 

let fromInventory transactionResult = 
    transactionResult.Inventory 

Answer 1

आमतौर पर, यदि आप प्रपत्र

let f x y value = value |> f1 x |> f2 y |> f3 

करने के लिए अपने पाइप लाइन अभिव्यक्ति की मालिश कर सकते हैं आप इसे

let f x y = f1 x >> f2 y >> f3 

लिए यह काफी नहीं है refactor कर सकते हैं यहां मामला, क्योंकि आपकी अभिव्यक्ति फ़ंक्शन कैल से शुरू होती है एल (buyFrom inventory qty), जिसका मूल्य तब fromInventory पर पाइप किया जाता है।

इस मामले में, मुझे लगता है कि आप

let purchase' inventory qty = 
    qty |> buyFrom inventory |> fromInventory |> reduceBy qty 

को refactor कर सकते हैं, लेकिन फिर तुम सच में किसी भी आगे नहीं मिल सकता है क्योंकि qty भी reduceBy लिए एक तर्क के रूप की जरूरत है।

मुझे लगता है कि आप रीडर या राज्य इकाई का उपयोग करके qty के दोनों घटनाओं को खत्म करने में सक्षम हो सकता है, लेकिन यह शायद ही प्रयास के लायक है।

का उपयोग करते हुए "आगे" समारोह रचना::

let purchase qty inventory = (buyFrom inventory >> fromInventory >> reduceBy qty) qty 

का उपयोग करते हुए "पिछड़े" समारोह संरचना (व्यक्तिगत रूप से, मुझे यकीन है कि मुझे पसंद नहीं कर रहा हूँ

Answer 2

एक बना फार्म के लिए सीधा अनुवाद या तो होगा शब्द "पिछड़े" क्योंकि इस अवधि के पारंपरिक mathemetical अर्थ में समारोह रचना है, यानी f << g = f ∘ g):

let purchase' qty inventory = reduceBy qty << fromInventory << buyFrom inventory <| qty 

के रूप में आप शायद रों कर सकते हैं उपर्युक्त उदाहरणों से, यह वास्तव में सबसे मूल्यवान है जब यह आपको अंतिम तर्क को पूरी तरह से छोड़ने देता है। इस उदाहरण में, आप ऐसा नहीं कर सकते क्योंकि आप qty पर दो बार निर्भर करते हैं, इसलिए मैं आपको यहां पाइपिंग के साथ चिपकने की सलाह दूंगा।

---

सामान्य तौर पर, यदि आप एक समारोह f(x) और एक समारोह g(x) है आप निम्न तरीकों से एक बना समारोह h(x) = (f ∘ g)(x) लिख सकते हैं:,

let h x = f (g (x)) 
let h x = x |> g |> f 
let h x = f << g <| x 
let h x = (g >> f) x 

दूसरा दो मामलों में, समारोह रचना का उपयोग कर आप x पूरी तरह से छोड़ सकते हैं।

let h = f << g 
let h = g >> f