Elm Language
कार्य और आंशिक अनुप्रयोग

वाक्य - विन्यास

• - बिना किसी तर्क के किसी फ़ंक्शन को परिभाषित करना वैसा ही है जैसा कि किसी मान को परिभाषित करना
  भाषा = "एल्म"
• - अपने नाम को बताते हुए किसी भी दलील के साथ कोई फ़ंक्शन कॉल करना
  भाषा: हिन्दी
• - पैरामीटर रिक्त स्थान से अलग हो जाते हैं और फ़ंक्शन के नाम का पालन करते हैं
  xy = x + y जोड़ें
• - एक फ़ंक्शन को उसी तरह से कॉल करें
  5 2 जोड़ें
• - आंशिक रूप से इसके कुछ मापदंडों को प्रदान करके एक फ़ंक्शन लागू करें
  वेतन वृद्धि = १ जोड़ें
• - बाईं ओर फ़ंक्शन पर दाईं ओर अभिव्यक्ति पास करने के लिए |>> ऑपरेटर का उपयोग करें
  दस = 9 |> वेतन वृद्धि
• - द <| ऑपरेटर बाईं तरफ फ़ंक्शन के दाईं ओर अभिव्यक्ति को पास करता है
  वेतन वृद्धि <| 5 4 जोड़ें
• - श्रंखला >> ऑपरेटर के साथ मिलकर दो कार्य करता है
  backwardYell = String.reverse >> String.toUpper
• - << समान दिशा में काम करता है
  backwardYell = String.toUpper << String.reverse
• - कोष्ठक में गैर-अल्फ़ान्यूमेरिक नाम वाला एक फ़ंक्शन एक नया ऑपरेटर बनाता है
  (#) xy = x * y
  दस = ५ # २
• - जब आप इसे कोष्ठक में लपेटते हैं तो कोई भी इन्फिक्स ऑपरेटर एक सामान्य कार्य बन जाता है
  दस = (+) ५ ५
• - वैकल्पिक प्रकार एनोटेशन फ़ंक्शन घोषणाओं के ऊपर दिखाई देते हैं
  isTen: इंट -> बूल
  isTen n = if n == 10 तो सही और गलत

अवलोकन

एल्म में फ़ंक्शन एप्लिकेशन सिंटैक्स कोष्ठक या अल्पविराम का उपयोग नहीं करता है, और इसके बजाय व्हाट्सएप-संवेदनशील है।

किसी फ़ंक्शन को परिभाषित करने के लिए, उसका नाम multiplyByTwo और तर्क x निर्दिष्ट करें, समान चिह्न के बाद कोई भी ऑपरेशन = जो फ़ंक्शन से लौटा है।

multiplyByTwo x =
    x * 2

किसी फ़ंक्शन को कॉल करने के लिए, उसका नाम और तर्क निर्दिष्ट करें:

multiplyByTwo 2  -- 4

ध्यान दें कि मल्टिप्लेयबॉट multiplyByTwo(2) तरह सिंटैक्स आवश्यक नहीं है (भले ही कंपाइलर शिकायत न करे)। कोष्ठक केवल वरीयता को हल करने के लिए सेवा करते हैं:

> multiplyByTwo multiplyByTwo 2
-- error, thinks it's getting two arguments, but it only needs one

> multiplyByTwo (multiplyByTwo 2)
4 : number

> multiplyByTwo 2 + 2
6 : number
-- same as (multiplyByTwo 2) + 2

> multiplyByTwo (2 + 2)
8 : number

लम्बोदर भाव

एल्म में लैम्ब्डा अभिव्यक्ति या अनाम कार्यों के लिए एक विशेष वाक्यविन्यास है:

\arguments -> returnedValue

उदाहरण के लिए, जैसा कि List.filter में देखा गया है:

> List.filter (\num -> num > 1) [1,2,3]
[2,3] : List number

गहराई, एक पिछड़े स्लेश करने के लिए अधिक, \ , लैम्ब्डा अभिव्यक्ति की शुरुआत चिह्नित करने के लिए प्रयोग किया जाता है, और तीर, -> , समारोह शरीर से परिसीमित तर्क किया जाता है। यदि अधिक तर्क हैं, तो वे एक स्थान से अलग हो जाते हैं:

normalFunction x y = x + y
-- is equivalent to
lambdaFunction = \x y -> x + y

> normalFunction 1 2
3 : number

> lambdaFunction 1 2
3 : number

स्थानीय चर

किसी फ़ंक्शन के अंदर स्थानीय चर को परिभाषित करना संभव है

• कोड पुनरावृत्ति को कम करें
• सबसेक्स को नाम दें
• पारित तर्कों की मात्रा कम करें।

इसके लिए निर्माण let ... in ... ।

bigNumbers =
    let
        allNumbers =
            [1..100]

        isBig number =
            number > 95
    in
        List.filter isBig allNumbers

> bigNumbers
[96,97,98,99,100] : List number

> allNumbers
-- error, doesn't know what allNumbers is!

के पहले भाग में परिभाषाओं के आदेश let कोई फर्क नहीं पड़ता!

outOfOrder =
    let
        x =
            y + 1  -- the compiler can handle this

        y =
            100
    in
        x + y

> outOfOrder
201 : number

आंशिक आवेदन

आंशिक अनुप्रयोग का अर्थ है किसी फ़ंक्शन को उसके पास कम तर्कों के साथ कॉल करना और परिणाम को दूसरे फ़ंक्शन के रूप में सहेजना (जो कि बाकी तर्कों की प्रतीक्षा करता है)।

multiplyBy: Int -> Int -> Int    
multiplyBy x y =
    x * y


multiplyByTwo : Int -> Int  -- one Int has disappeared! we now know what x is.
multiplyByTwo =
    multiplyBy 2


> multiplyByTwo 2
4 : Int

> multiplyByTwo 4
8 : Int

एक अकादमिक विचार के रूप में, एल्म पर्दे के पीछे करीने की वजह से ऐसा कर सकते हैं।

सख्त और देरी से मूल्यांकन

एल्म में, एक फ़ंक्शन के मान की गणना तब की जाती है जब अंतिम तर्क लागू किया जाता है। नीचे दिए गए उदाहरण में, log से डायग्नोस्टिक मुद्रित किया जाएगा जब एफ को 3 तर्कों के साथ लागू किया जाता है या अंतिम तर्क के साथ एफ का एक घुमावदार रूप लागू किया जाता है।

import String
import Debug exposing (log)

f a b c = String.join "," (log "Diagnostic" [a,b,c]) -- <function> : String -> String -> String -> String

f2 = f "a1" "b2" -- <function> : String -> String

f "A" "B" "C"
-- Diagnostic: ["A","B","C"]
"A,B,C" : String

f2 "c3"
-- Diagnostic: ["a1","b2","c3"]
"a1,b2,c3" : String

कई बार आप किसी फ़ंक्शन को तुरंत लागू होने से रोकना चाहते हैं। एल्म में एक विशिष्ट उपयोग Lazy.lazy जो फ़ंक्शन लागू होने पर नियंत्रित करने के लिए एक अमूर्तता प्रदान करता है।

lazy : (() -> a) -> Lazy a

आलसी अभिकलन एक () या Unit प्रकार के तर्क का कार्य करते हैं। इकाई प्रकार पारंपरिक रूप से प्लेसहोल्डर तर्क का प्रकार है। एक तर्क सूची में, इसी तर्क को _ रूप में निर्दिष्ट किया गया है, यह दर्शाता है कि मूल्य का उपयोग नहीं किया गया है। एल्म में इकाई मूल्य विशेष प्रतीक () द्वारा निर्दिष्ट किया गया है जो वैचारिक रूप से एक खाली टपल, या एक छेद का प्रतिनिधित्व कर सकता है। यह सी, जावास्क्रिप्ट और अन्य भाषाओं में खाली तर्क सूची जैसा दिखता है जो फ़ंक्शन कॉल के लिए कोष्ठक का उपयोग करते हैं, लेकिन यह एक सामान्य मूल्य है।

हमारे उदाहरण में, f को एक लंबोदर के साथ तुरंत मूल्यांकन किए जाने से बचाया जा सकता है:

doit f = f () -- <function> : (() -> a) -> a
whatToDo = \_ -> f "a" "b" "c" -- <function> : a -> String
-- f is not evaluated yet

doit whatToDo
-- Diagnostic: ["a","b","c"]
"a,b,c" : String

किसी फ़ंक्शन को आंशिक रूप से लागू किए जाने पर फ़ंक्शन मूल्यांकन में देरी होती है।

defer a f = \_ -> f a -- <function> : a -> (a -> b) -> c -> b

delayF = f "a" "b" |> defer "c" -- <function> : a -> String

doit delayF
-- Diagnostic: ["a","b","c"]
"a,b,c" : String

एल्म का always एक फ़ंक्शन always है, जिसका उपयोग मूल्यांकन में देरी के लिए नहीं किया जा सकता है। क्योंकि एल्म सभी फ़ंक्शन तर्कों का मूल्यांकन करता है, भले ही फ़ंक्शन एप्लिकेशन के परिणाम का उपयोग किया जाता है या नहीं, लेकिन फ़ंक्शन एप्लिकेशन को always से देरी का कारण नहीं होगा, क्योंकि f पूरी तरह से always पैरामीटर के रूप में लागू always ।

alwaysF = always (f "a" "b" "c") -- <function> : a -> String
-- Diagnostic: ["a","b","c"] -- Evaluation wasn't delayed.

Infix ऑपरेटरों और infix संकेतन

एल्म कस्टम इन्फिक्स ऑपरेटरों की परिभाषा की अनुमति देता है।

Infix ऑपरेटरों को एक फ़ंक्शन के नाम के आसपास कोष्ठक का उपयोग करके परिभाषित किया गया है।

निर्माण के लिए इनिक्स ऑपरेटर के इस उदाहरण पर विचार करें टुपल्स 1 => True -- (1, True) :

(=>) : a -> b -> ( a, b )
(=>) a b =
    ( a, b )

एल्म के अधिकांश कार्य उपसर्ग संकेतन में परिभाषित किए गए हैं।

फ़ंक्शन उच्चारण नाम को गंभीर उच्चारण वर्ण के साथ संलग्न करने से पहले पहले तर्क निर्दिष्ट करके कोई भी फ़ंक्शन का उपयोग करें:

import List exposing (append)


append [1,1,2] [3,5,8]   -- [1,1,2,3,5,8]
[1,1,2] `append` [3,5,8] -- [1,1,2,3,5,8]