async.nim

proc processClient(client: AsyncSocket): owned(Future[void]) =
  var retFuture_17906029 = newFuture("processClient")
  iterator processClientIter_17906030(): owned(FutureBase) {.closure.} =
    while true:
      var future_17906031 = recvLine(client, {SafeDisconn}, 1000000)
      yield future_17906031
      let line = read(future_17906031)
      if len(line) == 0:
        break
      for c in items(clients):
        var future_17906032 = send(c, line & "\c\n", {SafeDisconn})
        yield future_17906032
        read(future_17906032)
      for c in items(clients):
        var future_17906033 = send(c, line & "\c\n", {SafeDisconn})
        yield future_17906033
        read(future_17906033)
    complete(retFuture_17906029)

  let retFutUnown`gensym17906035 = retFuture_17906029
  var nameIterVar`gensym17906036 = processClientIter_17906030
  proc processClientNimAsyncContinue_17906034() {.closure.} =
    try:
      if not finished(nameIterVar`gensym17906036):
        var next`gensym17906037 = nameIterVar`gensym17906036()
        while not isNil(next`gensym17906037) and finished(next`gensym17906037):
          next`gensym17906037 = nameIterVar`gensym17906036()
          if finished(nameIterVar`gensym17906036):
            break
        if next`gensym17906037 == nil:
          if not finished(retFutUnown`gensym17906035):
            let msg`gensym17906038 = "Async procedure ($1) yielded `nil`, are you await\'ing a `nil` Future?"
            raise
              (ref AssertionError)(msg: msg`gensym17906038 % "processClient",
                                  parent: nil)
        else:
          {.gcsafe.}:
            {.push, hint[ConvFromXtoItselfNotNeeded]: false.}
            addCallback(next`gensym17906037, cast[proc () {.closure, gcsafe.}](processClientNimAsyncContinue_17906034))
            {.pop.}
    except:
      if finished(retFutUnown`gensym17906035):
        raise
      else:
        fail(retFutUnown`gensym17906035, getCurrentException())

  processClientNimAsyncContinue_17906034()
  return retFuture_17906029

proc serve(): owned(Future[void]) =
  var retFuture_17940064 = newFuture("serve")
  iterator serveIter_17940065(): owned(FutureBase) {.closure.} =
    clients = @[]
    var server = newAsyncSocket(AF_INET, SOCK_STREAM, IPPROTO_TCP, true)
    setSockOpt(server, OptReuseAddr, true, SOL_SOCKET)
    bindAddr(server, Port(12345), "")
    listen(server, SOMAXCONN)
    while true:
      var future_17940066 = accept(server, {SafeDisconn})
      yield future_17940066
      let c = read(future_17940066)
      add(clients, c)
      asyncCheck processClient(c)
    while true:
      var future_17940067 = accept(server, {SafeDisconn})
      yield future_17940067
      let client = read(future_17940067)
      add(clients, client)
      asyncCheck processClient(client)
    complete(retFuture_17940064)

  let retFutUnown`gensym17940069 = retFuture_17940064
  var nameIterVar`gensym17940070 = serveIter_17940065
  proc serveNimAsyncContinue_17940068() {.closure.} =
    try:
      if not finished(nameIterVar`gensym17940070):
        var next`gensym17940071 = nameIterVar`gensym17940070()
        while not isNil(next`gensym17940071) and finished(next`gensym17940071):
          next`gensym17940071 = nameIterVar`gensym17940070()
          if finished(nameIterVar`gensym17940070):
            break
        if next`gensym17940071 == nil:
          if not finished(retFutUnown`gensym17940069):
            let msg`gensym17940072 = "Async procedure ($1) yielded `nil`, are you await\'ing a `nil` Future?"
            raise
              (ref AssertionError)(msg: msg`gensym17940072 % "serve", parent: nil)
        else:
          {.gcsafe.}:
            {.push, hint[ConvFromXtoItselfNotNeeded]: false.}
            addCallback(next`gensym17940071,
                        cast[proc () {.closure, gcsafe.}](serveNimAsyncContinue_17940068))
            {.pop.}
    except:
      if finished(retFutUnown`gensym17940069):
        raise
      else:
        fail(retFutUnown`gensym17940069, getCurrentException())

  serveNimAsyncContinue_17940068()
  return retFuture_17940064

original.nim

import asyncnet, asyncdispatch
import macros

var clients {.threadvar.}: seq[AsyncSocket]

expandMacros:
  proc processClient(client: AsyncSocket) {.async.} =
    while true:
      let line = await client.recvLine()
      if line.len == 0: break
      for c in clients:
        await c.send(line & "\c\L")
      for c in clients:
        await c.send(line & "\c\L")

  proc serve() {.async.} =
    clients = @[]
    var server = newAsyncSocket()
    server.setSockOpt(OptReuseAddr, true)
    server.bindAddr(Port(12345))
    server.listen()
    
    while true:
      let c = await server.accept()
      clients.add c
      
      asyncCheck processClient(c)

    while true:
      let client = await server.accept()
      clients.add client
      
      asyncCheck processClient(client)

asyncCheck serve()
runForever()