Rename select functions to be more swifty (#6)

* swifty names

* readme

* readme

Benchmarks/Sources/Benchmarks/main.swift

@@ -242,12 +242,12 @@ func testMultiSelect<T: Initializable>(_ type: T.Type) async -> (String, String,
 
  while sum < 6 * 100_000 {
  await select {
- rx(a) { sum += 1 }
- rx(b) { sum += 1 }
- rx(c) { sum += 1 }
- rx(d) { sum += 1 }
- rx(e) { sum += 1 }
- rx(f) { sum += 1 }
+ receive(a) { sum += 1 }
+ receive(b) { sum += 1 }
+ receive(c) { sum += 1 }
+ receive(d) { sum += 1 }
+ receive(e) { sum += 1 }
+ receive(f) { sum += 1 }
  }
  }
  }

GolangVsSwift.md

@@ -117,7 +117,7 @@ Swift has reserve words for `case` and `default` and the operator support is not
 <tr style="vertical-align: top;">
 <td> 
 
-`rx(c)`
+`receive(c)`
 </td><td>
 
 `case <-c:`
@@ -127,7 +127,7 @@ Swift has reserve words for `case` and `default` and the operator support is not
 <tr>
 <td> 
 
-`rx(c) { v in ... }`
+`receive(c) { v in ... }`
 </td><td>
 
 `case v := <-c: ...`
@@ -137,7 +137,7 @@ Swift has reserve words for `case` and `default` and the operator support is not
 <tr>
 <td> 
 
-`tx(c, "foo")`
+`send("foo", to: c)`
 </td><td>
 
 `case c <- "foo":`
@@ -147,7 +147,7 @@ Swift has reserve words for `case` and `default` and the operator support is not
 <tr>
 <td> 
 
-`tx(c, "foo") { ... }`
+`send("foo", to: c) { ... }`
 </td><td>
 
 `case c <- "foo": ...`
@@ -198,7 +198,7 @@ let a = Channel<String>(capacity: 1)
 await a <- "foo"
 
 await select {
- rx(a) { av in
+ receive(a) { av in
  print(av!)
  }
  none {
@@ -235,7 +235,7 @@ default:
 let a = Channel<String>(capacity: 1)
 
 await select {
- tx(a, "foo")
+ send("foo", to: a)
  none {
  print("Not called")
  }
@@ -271,7 +271,7 @@ fmt.Println(<-a)
 let a = Channel<Bool>()
 
 await select {
- rx(a)
+ receive(a)
  none {
  print("Default case!")
  }

README.md

@@ -124,13 +124,13 @@ The loop will break when the channel is closed.
 
 ### Operations
 
-`rx(c)` receive a value, but do nothing with it. 
+`receive(c)` receive a value, but do nothing with it. 
 
-`rx(c) { v in ... }` receive a value and do something with it. 
+`receive(c) { v in ... }` receive a value and do something with it. 
 
-`tx(c, "foo")` send a value and do nothing.
+`send("foo", to: c)` send a value and do nothing.
 
-`tx(c, "foo") { ... }` run some code if a send is successful. 
+`send("foo", to: c) { ... }` run some code if a send is successful. 
 
 `none { ... }` if none of the channel operations were ready, none will execute instead. 
 
@@ -148,8 +148,8 @@ Task {
 
 // Will print foo or bar
 await select {
- rx(d) { print($0!) }
- rx(c) { print($0!) }
+ receive(d) { print($0!) }
+ receive(c) { print($0!) }
 }
 ```
 
@@ -165,9 +165,9 @@ for _ in (0..<10) {
 for _ in (0..<20) {
  await select {
  // receive from a and print it
- rx(a) { print($0!) }
+ receive(a) { print($0!) }
  // send "b" to b
- tx(b, "b")
+ send("b", to: b)
  // if both a and b suspend, print "NONE"
  none {
  print("NONE")

Sources/AsyncChannels/Select.swift

@@ -12,7 +12,7 @@ protocol SelectProtocol {
  func handle(_ sm: SelectSignal) async -> Bool
 }
 
-struct RxHandler<T>: SelectProtocol {
+struct ReceiveHandler<T>: SelectProtocol {
 
  private var chan: Channel<T>
  private let outFunc: (T?) async -> ()
@@ -48,7 +48,7 @@ struct NoneHandler: SelectProtocol {
  }
 }
 
-struct TxHandler<T>: SelectProtocol {
+struct SendHandler<T>: SelectProtocol {
  private var chan: Channel<T>
  private let val: T
  private let onSend: () async -> ()
@@ -102,24 +102,24 @@ public func select(@SelectCollector cases: () -> ([SelectHandler])) async {
  }
 }
 
-public func rx<T>(_ chan: Channel<T>, _ outFunc: @escaping (T?) async -> ()) -> SelectHandler {
- return SelectHandler(inner: RxHandler(chan: chan, outFunc: outFunc))
+public func receive<T>(_ chan: Channel<T>, _ outFunc: @escaping (T?) async -> ()) -> SelectHandler {
+ return SelectHandler(inner: ReceiveHandler(chan: chan, outFunc: outFunc))
 }
 
-public func rx<T>(_ chan: Channel<T>, _ outFunc: @escaping () async -> ()) -> SelectHandler {
- return SelectHandler(inner: RxHandler(chan: chan, outFunc: { _ in await outFunc() }))
+public func receive<T>(_ chan: Channel<T>, _ outFunc: @escaping () async -> ()) -> SelectHandler {
+ return SelectHandler(inner: ReceiveHandler(chan: chan, outFunc: { _ in await outFunc() }))
 }
 
-public func rx<T>(_ chan: Channel<T>) -> SelectHandler {
- return SelectHandler(inner: RxHandler(chan: chan, outFunc: { _ in }))
+public func receive<T>(_ chan: Channel<T>) -> SelectHandler {
+ return SelectHandler(inner: ReceiveHandler(chan: chan, outFunc: { _ in }))
 }
 
-public func tx<T>(_ chan: Channel<T>, _ val: T) -> SelectHandler {
- return SelectHandler(inner: TxHandler(chan: chan, val: val, onSend: {}))
+public func send<T>(_ val: T, to chan: Channel<T>) -> SelectHandler {
+ return SelectHandler(inner: SendHandler(chan: chan, val: val, onSend: {}))
 }
 
-public func tx<T>(_ chan: Channel<T>, _ val: T, _ onSend: @escaping () async -> ()) -> SelectHandler {
- return SelectHandler(inner: TxHandler(chan: chan, val: val, onSend: onSend))
+public func send<T>(_ val: T, to chan: Channel<T>, _ onSend: @escaping () async -> ()) -> SelectHandler {
+ return SelectHandler(inner: SendHandler(chan: chan, val: val, onSend: onSend))
 }
 
 public func none(handler: @escaping () async -> ()) -> SelectHandler {

Tests/AsyncChannelsTests/AsyncChannelTests.swift

@@ -17,8 +17,8 @@ final class AsyncTest: XCTestCase {
  let stop = Channel<Bool>()
  Task {
  await select {
- rx(stop)
- rx(sleep(for: duration)) {
+ receive(stop)
+ receive(sleep(for: duration)) {
  XCTFail("Test timed out")
  exit(1)
  }
@@ -186,13 +186,13 @@ final class AsyncTest: XCTestCase {
  }
 
  await select {
- rx(d) { await result <- $0! }
- rx(c) { await result <- $0! }
+ receive(d) { await result <- $0! }
+ receive(c) { await result <- $0! }
  }
 
  await select {
- rx(d) { await result <- $0! }
- rx(c) { await result <- $0! }
+ receive(d) { await result <- $0! }
+ receive(c) { await result <- $0! }
  }
  result.close()
 
@@ -214,8 +214,8 @@ final class AsyncTest: XCTestCase {
 
  for _ in (0..<6) {
  await select {
- rx(d) { await result <- $0! }
- rx(c) { await result <- $0! }
+ receive(d) { await result <- $0! }
+ receive(c) { await result <- $0! }
  }
  }
  result.close()
@@ -241,10 +241,10 @@ final class AsyncTest: XCTestCase {
 
  let drain: () async -> Void = {
  await select {
- rx(d) {
+ receive(d) {
  XCTFail()
  }
- rx(c) {
+ receive(c) {
  cCall += 1
  }
  none {
@@ -268,12 +268,12 @@ final class AsyncTest: XCTestCase {
 
  Task {
  await select {
- rx(c) { await result <- true }
+ receive(c) { await result <- true }
  none { XCTFail() }
  }
 
  await select {
- rx(c) { XCTFail() }
+ receive(c) { XCTFail() }
  none { await result <- true }
  }
  }
@@ -304,9 +304,9 @@ final class AsyncTest: XCTestCase {
  var done = false
  while !done {
  await select {
- rx(a) { await c <- $0! }
- rx(b) { await c <- $0! }
- rx(done1) { done = true }
+ receive(a) { await c <- $0! }
+ receive(b) { await c <- $0! }
+ receive(done1) { done = true }
  }
  }
  }
@@ -315,7 +315,7 @@ final class AsyncTest: XCTestCase {
  var count = 0
  while !done {
  await select {
- rx(c) {
+ receive(c) {
  count += 1
  if count >= 2 * total {
  done = true
@@ -345,10 +345,10 @@ final class AsyncTest: XCTestCase {
  var done = false
  while !done {
  await select {
- rx(a) { count += 1 }
- rx(b) { count += 1 }
- rx(c) { count += 1 }
- rx(d) { count += 1 }
+ receive(a) { count += 1 }
+ receive(b) { count += 1 }
+ receive(c) { count += 1 }
+ receive(d) { count += 1 }
  none {
  done = true
  }
@@ -358,7 +358,7 @@ final class AsyncTest: XCTestCase {
  XCTAssertEqual(40, count)
  }
 
- func testTx() async {
+ func testSend() async {
  let a = Channel<String>(capacity: 10)
  let b = Channel<String>(capacity: 10)
 
@@ -368,8 +368,8 @@ final class AsyncTest: XCTestCase {
 
  for _ in (0..<20) {
  await select {
- rx(a)
- tx(b, "b")
+ receive(a)
+ send("b", to: b)
  none {
  XCTFail()
  }
@@ -380,7 +380,7 @@ final class AsyncTest: XCTestCase {
  var done = false
  while !done {
  await select {
- rx(b) {
+ receive(b) {
  countB += 1
  XCTAssertEqual($0, "b")
  }
@@ -393,12 +393,12 @@ final class AsyncTest: XCTestCase {
  XCTAssertEqual(10, countB)
  }
 
- func testTxHandler() async {
+ func testSendHandler() async {
  let a = Channel<String>(capacity: 1)
  let testChan = Channel<Bool>(capacity: 1)
 
  await select {
- tx(a, "b") {
+ send("b", to: a) {
  await testChan <- true
  }
  none {
@@ -414,7 +414,7 @@ final class AsyncTest: XCTestCase {
 
  Task {
  await select {
- rx(a) { val in
+ receive(a) { val in
  XCTAssertNil(val)
  }
  }
@@ -487,7 +487,7 @@ final class AsyncTest: XCTestCase {
  var done = false
  while !done {
  await select {
- tx(c, true)
+ send(true, to: c)
  none {
  done = true
  }
@@ -525,7 +525,7 @@ final class AsyncTest: XCTestCase {
  var sum = 0
  while !done {
  await select {
- rx(c) {
+ receive(c) {
  sum += 1
  }
  none {