विशेषज्ञ प्रयोग

import gleam/result

pub fn main() -> Result(Int, Nil) {
  result.try(function1(), fn(a) {
    result.try(function2(), fn(b) {
      result.try(function3(), fn(c) {
        result.try(function4(), fn(d) {
          Ok(a + b + c + d)
        })
      })
    })
  })
}

import gleam/result

pub fn main() -> Result(Int, Nil) {
  use a <- result.try(function1())
  use b <- result.try(function2())
  use c <- result.try(function3())
  use d <- result.try(function4())
  Ok(a + b + c + d)
}

// This use expression
use a <- function(1, 2)
io.println("Hello!")
a

// Is equivalent to this normal function call
function(1, 2, fn(a) {
  io.println("Hello!")
  a
})

use a, b, c, d <- call_4_function()

use <- call_0_function()

pub fn call_twice(function: fn() -> t) -> #(t, t) {
  let first = function()
  let second = function()
  #(first, second)
}

निर्देश

डैफ्नी एक ऐसे सिस्टम पर काम कर रही हैं जो उनके प्रयोग चलाता है और उनके परिणाम रिकॉर्ड करता है। कोड का कुछ हिस्सा थोड़ा लंबा और दोहराव वाला हो गया है, इसलिए उन्होंने आपसे कहा है कि इस कोड को साफ करने के लिए आप कुछ use एक्सप्रेशन लिखिए।

1. with_retry फंक्शन बनाइए

कभी-कभी कोई प्रयोग किसी एक बार हुई गलती की वजह से विफल हो सकता है, इसलिए अगर कोई प्रयोग विफल हो जाए, तो डैफ्नी उसे दोबारा चलाकर देखना चाहती हैं कि वह दूसरी बार काम करता है या नहीं।

with_retry फंक्शन बनाइए, जो आर्गुमेंट के रूप में एक ऐसा फंक्शन लेता है जो परिणाम लौटाता है।

अगर वह फंक्शन Ok वैल्यू लौटाता है, तो with_retry को वही वैल्यू लौटानी चाहिए।

अगर वह फंक्शन Error वैल्यू लौटाता है, तो with_retry को उस फंक्शन को दोबारा कॉल करना चाहिए और उस कॉल का परिणाम लौटाना चाहिए।

डैफ्नी इस फंक्शन का इस्तेमाल ऐसे करेंगी:

pub fn main() {
  use <- with_retry
  // Perform the experiment here
}

2. record_timing फंक्शन बनाइए

डैफ्नी हर प्रयोग से पहले और बाद में टाइम लॉगिंग फंक्शन कॉल करके रिकॉर्ड करती हैं कि हर प्रयोग को चलने में कितना समय लगता है।

record_timing फंक्शन बनाइए, जो दो आर्गुमेंट लेता है:

• एक टाइम लॉगिंग फंक्शन, जो कोई आर्गुमेंट नहीं लेता और Nil लौटाता है।
• एक प्रयोग फंक्शन, जो कोई आर्गुमेंट नहीं लेता और परिणाम लौटाता है।

record_timing को पहले टाइम लॉगिंग फंक्शन कॉल करना चाहिए, फिर प्रयोग फंक्शन कॉल करना चाहिए, फिर दोबारा टाइम लॉगिंग फंक्शन कॉल करना चाहिए, और अंत में प्रयोग फंक्शन का परिणाम लौटाना चाहिए।

डैफ्नी इस फंक्शन का इस्तेमाल ऐसे करेंगी:

pub fn main() {
  use <- record_timing(time_logger)
  // Perform the experiment here
}

3. run_experiment फंक्शन बनाइए

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

run_experiment फंक्शन बनाइए, जो चार आर्गुमेंट लेता है:

• प्रयोग का नाम, एक String के रूप में।
• एक सेटअप फंक्शन, जो कोई आर्गुमेंट नहीं लेता और परिणाम लौटाता है।
• एक एक्शन फंक्शन, जो सेटअप फंक्शन की Ok वैल्यू को आर्गुमेंट के रूप में लेता है और परिणाम लौटाता है।
• एक रिकॉर्डिंग फंक्शन, जो सेटअप और एक्शन फंक्शन की Ok वैल्यू को आर्गुमेंट के रूप में लेता है और परिणाम लौटाता है।

अगर तीनों फंक्शन सफल होते हैं, तो run_experiment को Ok(#(experiment_name, recording_data)) लौटाना चाहिए।

अगर इनमें से कोई भी फंक्शन Error वैल्यू लौटाता है, तो run_experiment को वही वैल्यू लौटानी चाहिए।

डैफ्नी इस फंक्शन का इस्तेमाल ऐसे करेंगी:

pub fn main() {
  use setup_data, action_data <- run_experiment("Test 1", setup, action)
  // Record the results here
}