अनिवार्य प्रोग्रामिंग में, हमारे पास आमतौर पर कोड होता है जो इस तरह दिखता है:

func addOneToSlice(xs []int) []int {
  rs := make([]int, len(xs))
  for i, value := range xs {
    rs[i] = value   1
  }
  return rs
}

हालाँकि, लूप के बारे में निम्नलिखित पर ध्यान दें:

• प्रत्येक पुनरावृत्ति का एक विशिष्ट उद्देश्य होता है, जो वर्तमान तत्व में एक जोड़ना है।
• हालाँकि, प्रत्येक पुनरावृत्ति पर कोई प्रतिबंध नहीं है कि वह किस तत्व को संचालित कर सकता है।
• xs[i 2] और rs[i 3] के साथ संचालन करने से हमारे पास मौजूद कोड की संरचना में मौलिक परिवर्तन नहीं होगा, जबकि अंतिम परिणाम गलत हो जाएगा।

तुलना करें कि वही कार्य F# में कैसे किया जाएगा:

let rec addOneToList =
  function
  | [] -> []
  | x :: xs -> x   1 :: addOneToList xs

अब निम्नलिखित पर विचार करें:

• हमारे पास फ़ंक्शन तर्क के रूप में एक सूची है।
• कार्यात्मक भाषाओं में एक सूची एक लिंक की गई सूची है।
• लिंक की गई सूचियों पर कुशल और मानक संचालन हैं:
  • सिर x को उसकी पूंछ x से अलग करना
  • सिर पर कुछ करना x
  • एक पैरामीटर के रूप में पारित सूची की तुलना खाली सूची से की जा रही है []

इन प्रतिबंधों को देखते हुए, सूची के शीर्ष पर नहीं होने वाले किसी भी तत्व में 1 जोड़ने से हमारे फ़ंक्शन की संरचना में महत्वपूर्ण बदलाव आएगा।

अब तुलना करें कि दोनों शैलियों में गणना कैसे आगे बढ़ती है:

• कार्यात्मक शैली में, हम नए मूल्यों के साथ एक नया दायरा बनाते हैं, जिसमें उपरोक्त उदाहरण में एक पुनरावर्ती कॉल करना शामिल है।
• अनिवार्य शैली में, हम दायरे को बदले बिना मौजूदा मूल्य को बदलते हैं।

कार्यात्मक शैली में, कम्प्यूटेशनल प्रगति के साथ दोनों दायरे को मिलाने से निम्नलिखित परिणाम होते हैं:

• हम उत्परिवर्तन से बचते हैं।
• निष्पादन प्रवाह स्पष्ट है।
• जिस संरचना से हम निपट रहे हैं वह स्पष्ट हो जाती है।