/*---------------------------------------------------------------------------
  Copyright 2026, Tim Whiting, Microsoft Research, Daan Leijen.

  This is free software; you can redistribute it and/or modify it under the
  terms of the Apache License, Version 2.0. A copy of the License can be
  found in the LICENSE file at the root of this distribution.
---------------------------------------------------------------------------*/

// Asynchronous channels.
module async/channelstd/async/channel

import async/internalasync/internal
import async/asyncasync/async


// A _channel_ of values of type `:a`. Values can be asynchronously `emit`ed into
// a channel, and asynchronously `receive`d.
abstract value struct channelstd/async/channel/channel: V -> V<aa: V>(
  chidstd/async/channel/channel/chid: forall<a> (channel : channel<a>) -> int : intstd/core/types/int: V,
  statestd/async/channel/channel/state: forall<a> (channel : channel<a>) -> ref<global,channel-state<a>> : refstd/core/types/ref: (H, V) -> V<globalstd/core/types/global: H,channel-statestd/async/channel/channel-state: V -> V<aa: V>>
)

// todo: use queue data type for the values and listeners for better complexity
type channel-statestd/async/channel/channel-state: V -> V<aa: V>
  Emptystd/async/channel/Empty: forall<a> channel-state<a>
  Valuesstd/async/channel/Values: forall<a> (value : a, values : list<a>) -> channel-state<a>( valuevalue: $205 : aa: V, valuesvalues: list<$205> : liststd/core/types/list: V -> V<aa: V> = [std/core/types/Nil: forall<a> list<a>]std/core/types/Nil: forall<a> list<a> )
  Waitingstd/async/channel/Waiting: forall<a> (listener : (a) -> ioc (), listeners : list<(a) -> ioc ()>) -> channel-state<a>( listenerlistener: ($250) -> ioc () : aa: V -> iocstd/core/ioc: E (std/core/types/unit: V)std/core/types/unit: V, listenerslisteners: list<($250) -> ioc ()> : liststd/core/types/list: V -> V<aa: V -> iocstd/core/ioc: E (std/core/types/unit: V)std/core/types/unit: V> = [std/core/types/Nil: forall<a> list<a>]std/core/types/Nil: forall<a> list<a> )

fun from-valuesstd/async/channel/from-values: forall<a> (values : list<a>) -> channel-state<a>(valuesvalues: list<$297> : liststd/core/types/list: V -> V<aa: V> )result: -> total channel-state<334> : channel-statestd/async/channel/channel-state: V -> V<aa: V>
  match valuesvalues: list<$297>
    Nilstd/core/types/Nil: forall<a> list<a> -> Emptystd/async/channel/Empty: forall<a> channel-state<a>
    Consstd/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>(vv: $297,vsvs: list<$297>)  -> Values(vv: $297,vsvs: list<$297>)

fun from-waitingstd/async/channel/from-waiting: forall<a> (listeners : list<(a) -> ioc ()>) -> channel-state<a>(listenerslisteners: list<($339) -> ioc ()> : liststd/core/types/list: V -> V<aa: V -> iocstd/core/ioc: E (std/core/types/unit: V)std/core/types/unit: V>)result: -> total channel-state<378> : channel-statestd/async/channel/channel-state: V -> V<aa: V>
  match listenerslisteners: list<($339) -> ioc ()>
    Nilstd/core/types/Nil: forall<a> list<a> -> Emptystd/async/channel/Empty: forall<a> channel-state<a>
    Consstd/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>(ll: ($339) -> ioc (),lsls: list<($339) -> ioc ()>)  -> Waiting(ll: ($339) -> ioc (),lsls: list<($339) -> ioc ()>)

// Create a new asynchronous channel.
pub fun channelstd/async/channel/channel: forall<a> () -> async channel<a>()result: -> async channel<427> : asyncstd/async/async/async: E channelstd/async/channel/channel: V -> V<aa: V>
  async-iocstd/async/internal/async-ioc: (action : () -> ioc channel<$383>) -> async channel<$383>
    Channelstd/async/channel/Channel: forall<a> (chid : int, state : ref<global,channel-state<a>>) -> channel<a>(uniquestd/core/unique: () -> ioc int(), refstd/core/types/ref: (value : channel-state<$383>) -> ioc ref<global,channel-state<$383>>(Emptystd/async/channel/Empty: forall<a> channel-state<a>))

// Receive (and remove) a value from the channel: returns immediately if a value is available and otherwise
// waits asynchronously until a value becomes available.
pub fun receivestd/async/channel/receive: forall<a> (ch : channel<a>) -> <async,ndet> a( chch: channel<$523> : channelstd/async/channel/channel: V -> V<aa: V>)result: -> <async,ndet> 814 : <std/core/types/total: Easyncstd/async/async/async: E,ndetstd/core/types/ndet: X> aa: V
  fun setupsetup: (cb : ($523) -> ioc ()) -> ioc ()( cbcb: ($523) -> ioc () : __w-l47-c19: V -> iocstd/core/ioc: E (std/core/types/unit: V)std/core/types/unit: V )result: -> ioc () : iocstd/core/ioc: E (std/core/types/unit: V)std/core/types/unit: V
    val rr: ref<global,channel-state<$523>> = chch: channel<$523>.statestd/async/channel/channel/state: (channel : channel<$523>) -> ioc ref<global,channel-state<$523>>
    match !std/core/types/ref/(!): (ref : ref<global,channel-state<$523>>, @implicit/hdiv : hdiv<global,channel-state<$523>,<write<global>,alloc<global>,console,div,fsys,ndet,net,ui>>) -> ioc channel-state<$523>
?hdiv=iev@540rr: ref<global,channel-state<$523>>
      Emptystd/async/channel/Empty: forall<a> channel-state<a> -> rr: ref<global,channel-state<$523>> :=std/core/types/set: (ref : ref<global,channel-state<$523>>, assigned : channel-state<$523>) -> ioc () Waiting(cbcb: ($523) -> ioc (),[std/core/types/Nil: forall<a> list<a>]std/core/types/Nil: forall<a> list<a>)
      Waitingstd/async/channel/Waiting: forall<a> (listener : (a) -> ioc (), listeners : list<(a) -> ioc ()>) -> channel-state<a>(ll: ($523) -> ioc (),lsls: list<($523) -> ioc ()>) -> rr: ref<global,channel-state<$523>> :=std/core/types/set: (ref : ref<global,channel-state<$523>>, assigned : channel-state<$523>) -> ioc () Waiting(ll: ($523) -> ioc (),lsls: list<($523) -> ioc ()> ++std/core/list/(++): (xs : list<($523) -> ioc ()>, ys : list<($523) -> ioc ()>) -> ioc list<($523) -> ioc ()> [std/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>cbcb: ($523) -> ioc ()]std/core/types/Nil: forall<a> list<a>)
      Valuesstd/async/channel/Values: forall<a> (value : a, values : list<a>) -> channel-state<a>(vv: $523,vsvs: list<$523>)->   // this case should not happen due to `try-receive`
        rr: ref<global,channel-state<$523>> :=std/core/types/set: (ref : ref<global,channel-state<$523>>, assigned : channel-state<$523>) -> ioc () from-valuesstd/async/channel/from-values: (values : list<$523>) -> ioc channel-state<$523>(vsvs: list<$523>)
        cbcb: ($523) -> ioc ()(vv: $523)        

  match chch: channel<$523>.try-receivestd/async/channel/try-receive: (ch : channel<$523>) -> <async,ndet> maybe<$523>
    Juststd/core/types/Just: forall<a> (value : a) -> maybe<a>(vv: $523) -> vv: $523
    Nothingstd/core/types/Nothing: forall<a> maybe<a> -> await1-noexnstd/async/async/await1-noexn: (label : ? string, setup : (resume : ($523) -> ioc ()) -> ioc ()) -> <async,ndet> $523("receive "literal: string
count= 8 ++std/core/types/(++): (x : string, y : string) -> <async,ndet> string chch: channel<$523>.chidstd/async/channel/channel/chid: (channel : channel<$523>) -> <async,ndet> int.showstd/core/int/show: (i : int) -> <async,ndet> string, setupsetup: (cb : ($523) -> ioc ()) -> ioc ())

// Return immediately if a value is available on the channel and otherwise returns `Nothing`.
pub fun try-receivestd/async/channel/try-receive: forall<a> (ch : channel<a>) -> <async,ndet> maybe<a>( chch: channel<$432> : channelstd/async/channel/channel: V -> V<aa: V> )result: -> <async,ndet> maybe<518> : <std/core/types/total: Easyncstd/async/async/async: E,ndetstd/core/types/ndet: X> maybestd/core/types/maybe: V -> V<aa: V>
  async-iocstd/async/internal/async-ioc: (action : () -> ioc maybe<$432>) -> <async,ndet> maybe<$432>
    val rr: ref<global,channel-state<$432>> = chch: channel<$432>.statestd/async/channel/channel/state: (channel : channel<$432>) -> ioc ref<global,channel-state<$432>>
    match (!std/core/types/ref/(!): (ref : ref<global,channel-state<$432>>, @implicit/hdiv : hdiv<global,channel-state<$432>,<write<global>,alloc<global>,console,div,fsys,ndet,net,ui>>) -> ioc channel-state<$432>
?hdiv=iev@456rr: ref<global,channel-state<$432>>)
      Valuesstd/async/channel/Values: forall<a> (value : a, values : list<a>) -> channel-state<a>(vv: $432, vsvs: list<$432>) ->
        rr: ref<global,channel-state<$432>> :=std/core/types/set: (ref : ref<global,channel-state<$432>>, assigned : channel-state<$432>) -> ioc () from-valuesstd/async/channel/from-values: (values : list<$432>) -> ioc channel-state<$432>(vsvs: list<$432>)
        Juststd/core/types/Just: forall<a> (value : a) -> maybe<a>(vv: $432)
      _ -> Nothingstd/core/types/Nothing: forall<a> maybe<a>

pub fun emit-iostd/async/channel/emit-io: forall<a> (ch : channel<a>, value : a) -> ioc ()( chch: channel<$819> : channelstd/async/channel/channel: V -> V<aa: V>, valuevalue: $819 : aa: V )result: -> ioc () : iocstd/core/ioc: E (std/core/types/unit: V)std/core/types/unit: V
  val rr: ref<global,channel-state<$819>> = chch: channel<$819>.statestd/async/channel/channel/state: (channel : channel<$819>) -> ioc ref<global,channel-state<$819>>
  match !std/core/types/ref/(!): (ref : ref<global,channel-state<$819>>, @implicit/hdiv : hdiv<global,channel-state<$819>,<write<global>,alloc<global>,console,div,fsys,ndet,net,ui>>) -> ioc channel-state<$819>
?hdiv=iev@836rr: ref<global,channel-state<$819>>
    Emptystd/async/channel/Empty: forall<a> channel-state<a> -> rr: ref<global,channel-state<$819>> :=std/core/types/set: (ref : ref<global,channel-state<$819>>, assigned : channel-state<$819>) -> ioc () Values(valuevalue: $819, [std/core/types/Nil: forall<a> list<a>]std/core/types/Nil: forall<a> list<a>)
    Valuesstd/async/channel/Values: forall<a> (value : a, values : list<a>) -> channel-state<a>(vv: $819,vsvs: list<$819>)  -> rr: ref<global,channel-state<$819>> :=std/core/types/set: (ref : ref<global,channel-state<$819>>, assigned : channel-state<$819>) -> ioc () Values(vv: $819,vsvs: list<$819> ++std/core/list/(++): (xs : list<$819>, ys : list<$819>) -> ioc list<$819> [std/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>valuevalue: $819]std/core/types/Nil: forall<a> list<a>)
    Waitingstd/async/channel/Waiting: forall<a> (listener : (a) -> ioc (), listeners : list<(a) -> ioc ()>) -> channel-state<a>(ll: ($819) -> ioc (),lsls: list<($819) -> ioc ()>) ->
      rr: ref<global,channel-state<$819>> :=std/core/types/set: (ref : ref<global,channel-state<$819>>, assigned : channel-state<$819>) -> ioc () from-waitingstd/async/channel/from-waiting: (listeners : list<($819) -> ioc ()>) -> ioc channel-state<$819>(lsls: list<($819) -> ioc ()>)
      ll: ($819) -> ioc ()(valuevalue: $819)                // todo: use async-schedule-ioc ?

// Emit a value asynchronously into a channel.
pub fun emitstd/async/channel/emit: forall<a> (ch : channel<a>, value : a) -> async ()( chch: channel<$986> : channelstd/async/channel/channel: V -> V<aa: V>, valuevalue: $986 : aa: V )result: -> async () : asyncstd/async/async/async: E (std/core/types/unit: V)std/core/types/unit: V
  async-iocstd/async/internal/async-ioc: (action : () -> ioc ()) -> async ()
    emit-iostd/async/channel/emit-io: (ch : channel<$986>, value : $986) -> ioc ()(chch: channel<$986>,valuevalue: $986)

// Emit a value asynchronously into a channel such that the
// current strand continues immediately
pub fun schedule-emitstd/async/channel/schedule-emit: forall<a> (ch : channel<a>, value : a) -> async ()( chch: channel<$1017> : channelstd/async/channel/channel: V -> V<aa: V>, valuevalue: $1017 : aa: V )result: -> async () : asyncstd/async/async/async: E (std/core/types/unit: V)std/core/types/unit: V
  async-schedule-iocstd/async/internal/async-schedule-ioc: (action : () -> ioc ()) -> async ()
    emit-iostd/async/channel/emit-io: (ch : channel<$1017>, value : $1017) -> ioc ()(chch: channel<$1017>,valuevalue: $1017)    

fun trace-channelstd/async/channel/trace-channel: forall<a> (msg : string, ch : channel<a>) -> <async,ndet> ()( msgmsg: string : stringstd/core/types/string: V, chch: channel<$1445> : channelstd/async/channel/channel: V -> V<aa: V> )result: -> <async,ndet> () : <std/core/types/total: Easyncstd/async/async/async: E,ndetstd/core/types/ndet: X> (std/core/types/unit: V)std/core/types/unit: V
  async-iocstd/async/internal/async-ioc: (action : () -> ioc ()) -> <async,ndet> ()
    trace-channel-iostd/async/channel/trace-channel-io: (msg : string, ch : channel<$1445>) -> ioc ()( msgmsg: string, chch: channel<$1445> )

fun trace-channel-iostd/async/channel/trace-channel-io: forall<a> (msg : string, ch : channel<a>) -> ioc ()( msgmsg: string : stringstd/core/types/string: V, chch: channel<$1045> : channelstd/async/channel/channel: V -> V<aa: V> )result: -> ioc () : iocstd/core/ioc: E (std/core/types/unit: V)std/core/types/unit: V
  val msgxmsgx: string = msgmsg: string ++std/core/types/(++): (x : string, y : string) -> ioc string ": id="literal: string
count= 5 ++std/core/types/(++): (x : string, y : string) -> ioc string chch: channel<$1045>.chidstd/async/channel/channel/chid: (channel : channel<$1045>) -> ioc int.showstd/core/int/show: (i : int) -> ioc string
  val rr: ref<global,channel-state<$1045>> = chch: channel<$1045>.statestd/async/channel/channel/state: (channel : channel<$1045>) -> ioc ref<global,channel-state<$1045>>
  match !std/core/types/ref/(!): (ref : ref<global,channel-state<$1045>>, @implicit/hdiv : hdiv<global,channel-state<$1045>,<alloc<global>,console,div,fsys,ndet,net,ui,write<global>>>) -> ioc channel-state<$1045>
?hdiv=iev@1163rr: ref<global,channel-state<$1045>>
    Emptystd/async/channel/Empty: forall<a> channel-state<a>         -> tracestd/core/debug/trace: (message : string) -> ioc ()(msgxmsgx: string ++std/core/types/(++): (x : string, y : string) -> ioc string ", empty"literal: string
count= 7)
    Valuesstd/async/channel/Values: forall<a> (value : a, values : list<a>) -> channel-state<a>(vv: $1045,vsvs: list<$1045>)  -> trace-anystd/core/debug/trace-any: (message : string, x : $1045) -> ioc ()(msgxmsgx: string ++std/core/types/(++): (x : string, y : string) -> ioc string ", full: "literal: string
count= 8 ++std/core/types/(++): (x : string, y : string) -> ioc string (1literal: int
dec  = 1
hex8 = 0x01
bit8 = 0b00000001 +std/core/int/(+): (x : int, y : int) -> ioc int vsvs: list<$1045>.lengthstd/core/list/length: (xs : list<$1045>) -> ioc int).showstd/core/int/show: (i : int) -> ioc string ++std/core/types/(++): (x : string, y : string) -> ioc string ": "literal: string
count= 2, vv: $1045 )
    Waitingstd/async/channel/Waiting: forall<a> (listener : (a) -> ioc (), listeners : list<(a) -> ioc ()>) -> channel-state<a>(_,lsls: list<($1045) -> ioc ()>) -> tracestd/core/debug/trace: (message : string) -> ioc ()(msgxmsgx: string ++std/core/types/(++): (x : string, y : string) -> ioc string ", listeners: "literal: string
count= 13 ++std/core/types/(++): (x : string, y : string) -> ioc string (1literal: int
dec  = 1
hex8 = 0x01
bit8 = 0b00000001 +std/core/int/(+): (x : int, y : int) -> ioc int lsls: list<($1045) -> ioc ()>.lengthstd/core/list/length: (xs : list<($1045) -> ioc ()>) -> ioc int).showstd/core/int/show: (i : int) -> ioc string)

fun trace-anyxstd/async/channel/trace-anyx: forall<a> (s : string, x : a) -> async ()( ss: string : stringstd/core/types/string: V, xx: $1476 : aa: V )result: -> async () : asyncstd/async/async/async: E (std/core/types/unit: V)std/core/types/unit: V
  trace-anystd/core/debug/trace-any: (message : string, x : $1476) -> async ()(ss: string,xx: $1476)

// Internal: Treat `do-await` as `no-wait` calls, and emit the resumption eventually in the given channel.
pub fun emit-on-awaitstd/async/channel/emit-on-await: forall<e> (ch : channel<() -> <async|e> ()>, action : () -> <async|e> ()) -> <async|e> ()(chch: channel<() -> <async|$1497> ()> : channelstd/async/channel/channel: V -> V<() -> <asyncstd/async/async/async: E|ee: E> (std/core/types/unit: V)std/core/types/unit: V>, actionaction: () -> <async|$1497> () : () -> <asyncstd/async/async/async: E|ee: E> (std/core/types/unit: V)std/core/types/unit: V )result: -> <async|1798> () : <asyncstd/async/async/async: E|ee: E> (std/core/types/unit: V)std/core/types/unit: V
  overridehandler: (() -> <async,async-await|$1497> ()) -> <async|$1497> () handle<async-awaitstd/async/internal/async-await: (E, V) -> V>(actionaction: () -> <async|$1497> ())
    raw ctl do-awaitdo-await: (setup : await-setup<_1506>, scope : async-scope, lab : string, rcontext : resume-context<await-result<_1506>,<async-await,async-cancel,async-ioc,discontinue|$1497>,<async-await,async-await,async-cancel,async-ioc,discontinue|$1497>,()>) -> <async|$1497> ()
(setupsetup: await-setup<_1506>,scopescope: async-scope,lablab: string)
      // turn awaits into no-awaits, allowing other strands to execute
      no-awaitstd/async/internal/no-await: (setup : await-setup<_1506>, async-scope : async-scope, label : string, cb : (await-result<_1506>) -> ioc ()) -> <async|$1497> ()(setupsetup: (evloop : event-loop, resume : (result : await-result<_1506>, isdone : bool) -> ioc ()) -> ioc error<dispose-fn>, scopescope: async-scope, "emit-on-await "literal: string
count= 14 ++std/core/types/(++): (x : string, y : string) -> <async|$1497> string chch: channel<() -> <async|$1497> ()>.chidstd/async/channel/channel/chid: (channel : channel<() -> <async|$1497> ()>) -> <async|$1497> int.showstd/core/int/show: (i : int) -> <async|$1497> string ++std/core/types/(++): (x : string, y : string) -> <async|$1497> string ": "literal: string
count= 2 ++std/core/types/(++): (x : string, y : string) -> <async|$1497> string lablab: string) fnfn: (res : await-result<_1506>) -> ioc ()(resres: await-result<_1506>)
        chch: channel<() -> <async|$1497> ()>.emit-iostd/async/channel/emit-io: (ch : channel<() -> <async|$1497> ()>, value : () -> <async|$1497> ()) -> ioc ()( fnfn: () -> <async|$1497> ()() rcontextrcontext: resume-context<await-result<_1506>,<async-await,async-cancel,async-ioc,discontinue|$1497>,<async-await,async-await,async-cancel,async-ioc,discontinue|$1497>,()>.resumestd/core/hnd/resume: (r : resume-context<await-result<_1506>,<async-await,async-cancel,async-ioc,discontinue|$1497>,<async-await,async-await,async-cancel,async-ioc,discontinue|$1497>,()>, x : await-result<_1506>) -> <async|$1497> ()(resres: await-result<_1506>) )
      (std/core/types/Unit: ())std/core/types/Unit: ()
    fun no-awaitno-await: (setup : await-setup<_1509>, scope : async-scope, l : string, f : (await-result<_1509>) -> ioc ()) -> <async|$1497> ()(setupsetup: await-setup<_1509>,scopescope: async-scope,ll: string,ff: (await-result<_1509>) -> ioc ()) no-awaitstd/async/internal/no-await: (setup : await-setup<_1509>, async-scope : async-scope, label : string, cb : (await-result<_1509>) -> ioc ()) -> <async|$1497> ()(setupsetup: (evloop : event-loop, resume : (result : await-result<_1509>, isdone : bool) -> ioc ()) -> ioc error<dispose-fn>,scopescope: async-scope,ll: string,ff: (await-result<_1509>) -> ioc ())