harn-stdlib 0.8.26

Embedded Harn standard library source catalog
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119

// std/async — Async utilities: polling, waiting, retrying.
// wait_for(timeout_ms, interval_ms, predicate) -> Result
// Repeatedly calls predicate() with interval_ms sleep between attempts.
// Returns Ok(value) with the first truthy return value, or Err("timeout").
//
// Example:
//   import { wait_for } from "std/async"
//   let result = wait_for(5000, 500, { -> metadata_get("status") == "ready" })
/**
 * wait_for.
 *
 * @effects: [time]
 * @allocation: heap
 * @errors: []
 * @api_stability: stable
 * @example: wait_for(timeout_ms, interval_ms, predicate)
 */
pub fn wait_for(timeout_ms, interval_ms, predicate) {
  let end_time = timestamp() * 1000 + timeout_ms
  let interval = interval_ms
  if interval <= 0 {
    interval = 100
  }
  while timestamp() * 1000 < end_time {
    let value = predicate()
    if value {
      return Ok(value)
    }
    sleep(interval)
  }
  // One final check after deadline
  let value = predicate()
  if value {
    return Ok(value)
  }
  return Err("timeout")
}

// retry_until(max_attempts, predicate) -> Result
// Calls predicate() up to max_attempts times with no delay.
// Returns Ok(value) on first truthy result, or Err("exhausted").
/**
 * retry_until.
 *
 * @effects: []
 * @allocation: heap
 * @errors: []
 * @api_stability: stable
 * @example: retry_until(max_attempts, predicate)
 */
pub fn retry_until(max_attempts, predicate) {
  var i = 0
  while i < max_attempts {
    let value = predicate()
    if value {
      return Ok(value)
    }
    i = i + 1
  }
  return Err("exhausted")
}

// retry_predicate_with_backoff(max_attempts, base_ms, predicate) -> Result
// Calls predicate() with exponential backoff (base_ms * 2^attempt).
// Returns Ok(value) on first truthy result, or Err("exhausted").
/**
 * retry_predicate_with_backoff.
 *
 * @effects: []
 * @allocation: heap
 * @errors: []
 * @api_stability: stable
 * @example: retry_predicate_with_backoff(max_attempts, base_ms, predicate)
 */
pub fn retry_predicate_with_backoff(max_attempts, base_ms, predicate) {
  var attempt = 0
  while attempt < max_attempts {
    let value = predicate()
    if value {
      return Ok(value)
    }
    attempt = attempt + 1
    if attempt < max_attempts {
      let delay = base_ms * pow(2, attempt - 1)
      sleep(delay)
    }
  }
  return Err("exhausted")
}

// circuit_call(name, closure) -> Result
// Calls the closure only if the circuit breaker is not open.
// Records success/failure on the circuit breaker automatically.
// Returns Err("circuit_open") if the circuit is open.
// In half_open state, allows one call through as a probe.
/**
 * circuit_call.
 *
 * @effects: []
 * @allocation: heap
 * @errors: []
 * @api_stability: stable
 * @example: circuit_call(name, closure)
 */
pub fn circuit_call(name, closure) {
  let state = circuit_check(name)
  if state == "open" {
    return Err("circuit_open")
  }
  let result = try {
    closure()
  }
  if is_ok(result) {
    circuit_record_success(name)
  } else {
    circuit_record_failure(name)
  }
  return result
}