call-forever

Author: giacomocavalieri

CHANGELOG.md

@@ -1,5 +1,10 @@
 # Changelog
 
+## Unreleased
+
+- The `gleam/erlang/process` module gains the `call_forever` and
+  `try_call_forever` functions.
+
 ## v0.28.0 - 2024-10-24
 
 - The `gleam/erlang/process` module gains the `deselecting_process_down`

src/gleam/erlang/process.gleam

@@ -620,6 +620,54 @@ pub fn call(
   resp
 }
 
+/// Similar to the `call` function but will wait forever for a message to
+/// arrive rather than timing out after a specified amount of time.
+///
+/// If the receiving process exits, the calling process crashes.
+/// If you wish an error to be returned instead see the `try_call_forever`
+/// function.
+///
+pub fn call_forever(
+  subject: Subject(request),
+  make_request: fn(Subject(response)) -> request,
+) -> response {
+  let assert Ok(response) = try_call_forever(subject, make_request)
+  response
+}
+
+/// Similar to the `try_call` function but will wait forever for a message
+/// to arrive rather than timing out after a specified amount of time.
+///
+/// If the receiving process exits then an error is returned.
+///
+pub fn try_call_forever(
+  subject: Subject(request),
+  make_request: fn(Subject(response)) -> request,
+) -> Result(response, CallError(c)) {
+  let reply_subject = new_subject()
+
+  // Monitor the callee process so we can tell if it goes down (meaning we
+  // won't get a reply)
+  let monitor = monitor_process(subject_owner(subject))
+
+  // Send the request to the process over the channel
+  send(subject, make_request(reply_subject))
+
+  // Await a reply or handle failure modes (timeout, process down, etc)
+  let result =
+    new_selector()
+    |> selecting(reply_subject, Ok)
+    |> selecting_process_down(monitor, fn(down) {
+      Error(CalleeDown(reason: down.reason))
+    })
+    |> select_forever
+
+  // Demonitor the process and close the channels as we're done
+  demonitor_process(monitor)
+
+  result
+}
+
 /// Creates a link between the calling process and another process.
 ///
 /// When a process crashes any linked processes will also crash. This is useful

test/gleam/erlang/process_test.gleam

@@ -199,6 +199,26 @@ pub fn try_call_timeout_test() {
     process.try_call(call_subject, fn(x) { x }, 10)
 }
 
+pub fn try_call_forever_test() {
+  let parent_subject = process.new_subject()
+
+  process.start(linked: True, running: fn() {
+    // Send the child subject to the parent so it can call the child
+    let child_subject = process.new_subject()
+    process.send(parent_subject, child_subject)
+    // Wait for the subject to be messaged
+    let assert Ok(#(x, reply)) = process.receive(child_subject, 50)
+    // Reply
+    process.send(reply, x + 1)
+  })
+
+  let assert Ok(call_subject) = process.receive(parent_subject, 50)
+
+  // Call the child process and get a response.
+  let assert Ok(2) =
+    process.try_call_forever(call_subject, fn(subject) { #(1, subject) })
+}
+
 pub fn call_test() {
   let parent_subject = process.new_subject()
 
@@ -218,6 +238,26 @@ pub fn call_test() {
   let assert 2 = process.call(call_subject, fn(subject) { #(1, subject) }, 50)
 }
 
+pub fn call_forever_test() {
+  let parent_subject = process.new_subject()
+
+  process.start(linked: True, running: fn() {
+    // Send the child subject to the parent so it can call the child
+    let child_subject = process.new_subject()
+    process.send(parent_subject, child_subject)
+    // Wait for the subject to be messaged
+    let assert Ok(#(x, reply)) = process.receive(child_subject, 50)
+    // Reply
+    process.send(reply, x + 1)
+  })
+
+  let assert Ok(call_subject) = process.receive(parent_subject, 50)
+
+  // Call the child process and get a response.
+  let assert 2 =
+    process.call_forever(call_subject, fn(subject) { #(1, subject) })
+}
+
 @external(erlang, "erlang", "send")
 fn send(a: process.Pid, b: anything) -> Nil