F#
एफ # में डिजाइन पैटर्न कार्यान्वयन

F # में डेटा चालित प्रोग्रामिंग

F# डेटा-चालित प्रोग्रामिंग में टाइप-इनफेरेंस और आंशिक अनुप्रयोग के लिए धन्यवाद, रसीला और पठनीय है।

आइए कल्पना करें कि हम कार बीमा बेच रहे हैं। इससे पहले कि हम इसे ग्राहक को बेचने की कोशिश करें, हम यह निर्धारित करने की कोशिश करते हैं कि ग्राहक ग्राहक की सेक्स और उम्र की जाँच करके हमारी कंपनी के लिए एक वैध संभावित ग्राहक है या नहीं।

एक साधारण ग्राहक मॉडल:

type Sex =
  | Male
  | Female

type Customer =
  {
    Name    : string
    Born    : System.DateTime
    Sex     : Sex
  }

आगे हम एक बहिष्करण सूची (तालिका) को परिभाषित करना चाहते हैं ताकि यदि कोई ग्राहक बहिष्करण सूची में किसी पंक्ति से मेल खाता हो तो ग्राहक आपकी कार बीमा नहीं खरीद सकता है।

//  If any row in this list matches the Customer, the customer isn't eligible for the car insurance.
let exclusionList =
  let __          _   = true
  let olderThan   x y = x < y
  let youngerThan x y = x > y
  [|
//  Description                         Age               Sex
    "Not allowed for senior citizens" , olderThan   65  , __
    "Not allowed for children"        , youngerThan 16  , __
    "Not allowed for young males"     , youngerThan 25  , (=) Male
  |]

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

अंत में, हम एक फ़ंक्शन को परिभाषित करते हैं जो ग्राहकों को दो बाल्टी में विभाजित करने के लिए बहिष्करण सूची (एक तालिका) का उपयोग करता है: संभावित और अस्वीकृत ग्राहक।

// Splits customers into two buckets: potential customers and denied customers.
// The denied customer bucket also includes the reason for denying them the car insurance
let splitCustomers (today : System.DateTime) (cs : Customer []) : Customer []*(string*Customer) [] =
  let potential = ResizeArray<_> 16 // ResizeArray is an alias for System.Collections.Generic.List
  let denied    = ResizeArray<_> 16

  for c in cs do
    let age = today.Year - c.Born.Year
    let sex = c.Sex
    match exclusionList |> Array.tryFind (fun (_, testAge, testSex) -> testAge age && testSex sex) with
    | Some (description, _, _)  -> denied.Add (description, c)
    | None                      -> potential.Add c

  potential.ToArray (), denied.ToArray ()

रैप करने के लिए, आइए कुछ ग्राहकों को परिभाषित करें और देखें कि क्या वे हमारे बीच कार बीमा के लिए कोई संभावित ग्राहक हैं:

let customers =
  let c n s y m d: Customer = { Name = n; Born = System.DateTime (y, m, d); Sex = s }
  [|
//    Name                      Sex     Born
    c "Clint Eastwood Jr."      Male    1930 05 31
    c "Bill Gates"              Male    1955 10 28
    c "Melina Gates"            Female  1964 08 15
    c "Justin Drew Bieber"      Male    1994 03 01
    c "Sophie Turner"           Female  1996 02 21
    c "Isaac Hempstead Wright"  Male    1999 04 09
  |]

[<EntryPoint>]
let main argv =
  let potential, denied = splitCustomers (System.DateTime (2014, 06, 01)) customers
  printfn "Potential Customers (%d)\n%A" potential.Length potential
  printfn "Denied Customers (%d)\n%A"    denied.Length    denied
  0

यह प्रिंट:

Potential Customers (3)
[|{Name = "Bill Gates";
   Born = 1955-10-28 00:00:00;
   Sex = Male;}; {Name = "Melina Gates";
                  Born = 1964-08-15 00:00:00;
                  Sex = Female;}; {Name = "Sophie Turner";
                                   Born = 1996-02-21 00:00:00;
                                   Sex = Female;}|]
Denied Customers (3)
[|("Not allowed for senior citizens", {Name = "Clint Eastwood Jr.";
                                       Born = 1930-05-31 00:00:00;
                                       Sex = Male;});
  ("Not allowed for young males", {Name = "Justin Drew Bieber";
                                   Born = 1994-03-01 00:00:00;
                                   Sex = Male;});
  ("Not allowed for children", {Name = "Isaac Hempstead Wright";
                                Born = 1999-04-09 00:00:00;
                                Sex = Male;})|]