रहस्य

pub fn main() {
  // Assign the function to a variable
  let f = add_one
  
  // Invoke the function
  f(1) // -> 2
  f(2) // -> 3
}

fn add_one(x) {
  x + 1
}

// Define the function
let f = fn(x) { x + 1 }

// Invoke the function
f(1) // -> 2
f(2) // -> 3

fn(Int, Float) -> Int

let secret_number = 42

// This function always returns 42
fn() { secret_number }

// Anonymous function syntax
let f = fn(x) { my_function(1, 2, x) }

// Function capture syntax
let f = my_function(1, 2, _)

निर्देश

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

हर कार्य के लिए, एक अनाम फंक्शन लौटाइए जिसे कॉल करने वाले स्कोप से कॉल किया जा सके।

1. जोड़ने वाला फंक्शन बनाइए

secret_add को लागू कीजिए। इसे एक ऐसा फंक्शन लौटाना चाहिए जो एक आर्गुमेंट लेता है और उसमें secret_add को दिए गए आर्गुमेंट को जोड़ता है।

let adder = secret_add(2)
adder(2)
// -> 4

2. घटाने वाला फंक्शन बनाइए

secret_subtract को लागू कीजिए। इसे एक ऐसा फंक्शन लौटाना चाहिए जो एक आर्गुमेंट लेता है और उस आर्गुमेंट में से secret_subtract को दी गई गुप्त वैल्यू को घटाता है।

let subtractor = secret_subtract(2)
subtractor(3)
// -> 1

3. गुणा करने वाला फंक्शन बनाइए

secret_multiply को लागू कीजिए। इसे एक ऐसा फंक्शन लौटाना चाहिए जो एक आर्गुमेंट लेता है और उसे secret_multiply को दी गई गुप्त वैल्यू से गुणा करता है।

let multiplier = secret_multiply(7)
multiplier(3)
// -> 21

4. भाग देने वाला फंक्शन बनाइए

secret_divide को लागू कीजिए। इसे एक ऐसा फंक्शन लौटाना चाहिए जो एक आर्गुमेंट लेता है और उसे secret_divide को दी गई गुप्त वैल्यू से भाग देता है।

let divider = secret_divide(3)
divider(32)
// -> 10

5. फंक्शन कॉम्बाइनर बनाइए

secret_combine को लागू कीजिए। इसे एक ऐसा फंक्शन लौटाना चाहिए जो एक आर्गुमेंट लेता है और उस पर secret_combine को दिए गए दोनों फंक्शनों को क्रम से लागू करता है।

let multiply = secret_multiply(7)
let divide = secret_divide(3)
let combined = secret_combine(multiply, divide)

combined(6)
// -> 14