Rename object 'Time' -> 'TimeChannels' since 'Time' can be confused with general time utils.

Author: yruslan

README.md

@@ -285,37 +285,36 @@ Channel.select(
 ```
 
 #### Time.after()
-Like in Go, you can use `Time.after(duration)` to generate a channel that sends a message after the specified time has
-passed. You don't need to close the channel afterward.
+In Go, you can use `Time.After(duration)` to generate a channel that sends a message after the specified time has
+passed. You don't need to close the channel afterward. The Scala implementation is `TimeChannels.after(duration)` 
 
 ```scala
 import com.github.yruslan.channel._
 
 Channel.select(
-    someChannel.recver{v => println(s"Got a message in time: $v")},
-    Time.after(Duration(10, TimeUnit.SECONDS)).recver{ v => println("Time is out!") }
+  someChannel.recver { v => println(s"Got a message in time: $v") },
+  TimeChannels.after(Duration(10, TimeUnit.SECONDS)).recver { v => println("Time is out!") }
 )
 ```
 
 #### Time.newTicker()
-Like in Go, you can use `Time.newTicker(duration)` to generate a channel that sends a message after the specified time.
+In Go, you can use `Time.newTicker(duration)` to generate a channel that sends a message after the specified time.
 When the message is consumed, the ticker will generate another message after the same time duration.
-Tickers should be closed after they are not in use.
+Tickers should be closed after they are not in use. The Scala implementation is `TimeChannels.ticker(duration)`
 
 ```scala
 import com.github.yruslan.channel._
 
-val ticker = Time.newTicker(Duration(10, TimeUnit.SECONDS))
+val ticker = TimeChannels.ticker(Duration(10, TimeUnit.SECONDS))
 
 Channel.select(
-    someChannel.recver{v => println(s"Got a message: $v")},
-    ticker.recver{ _ => println("Tick.") }
+  someChannel.recver { v => println(s"Got a message: $v") },
+  ticker.recver { _ => println("Tick.") }
 )
 
 ticker.close()
 ```
 
-
 ### Non-blocking methods
 Go supports non-blocking channel operation by the elegant `default` clause in the `select` statement. The scala port
 adds separate methods that support non-blocking operations: `trySend()`, `tryRecv()` and `trySelect()`. There is an

src/main/scala/com/github/yruslan/channel/Time.scala renamed to src/main/scala/com/github/yruslan/channel/TimeChannels.scala

@@ -22,13 +22,13 @@ import scala.concurrent.duration.Duration
 /**
   * The object contains channel generators similar to GoLang: https://gobyexample.com/tickers
   */
-object Time {
+object TimeChannels {
   /**
     * Create a channel that gets a single message after the specified duration, and then closes.
     *
     * Example:
     * {{{
-    *   val after = Time.after(Duration(10, TimeUnit.MILLISECONDS))
+    *   val after = TimeChannels.after(Duration(10, TimeUnit.MILLISECONDS))
     *   after.recv()
     *   // 10 ms has passed.
     *   // You don't need to close the channel
@@ -49,13 +49,13 @@ object Time {
     * Create a ticker channel, see https://gobyexample.com/tickers
     *
     * {{{
-    *   val ticker = Time.newTicker(Duration(10, TimeUnit.MILLISECONDS))
+    *   val ticker = TimeChannels.ticker(Duration(10, TimeUnit.MILLISECONDS))
     *   val instant = ticker.recv()
     *   ticker.close()
     * }}}
     *
     */
-  def newTicker(duration: Duration)(implicit executor: ExecutionContext): Channel[Instant] = {
+  def ticker(duration: Duration)(implicit executor: ExecutionContext): Channel[Instant] = {
     val channel = Channel.make[Instant]
     Future {
       while (!channel.isClosed) {

src/test/scala/com/github/yruslan/channel/TimeSuite.scala renamed to src/test/scala/com/github/yruslan/channel/TimeChannelsSuite.scala

@@ -22,12 +22,12 @@ import java.util.concurrent.TimeUnit
 import scala.concurrent.ExecutionContext.Implicits.global
 import scala.concurrent.duration.Duration
 
-class TimeSuite extends AnyWordSpec {
-  "newTicker" should {
+class TimeChannelsSuite extends AnyWordSpec {
+  "ticker" should {
     "generate a ticker that ticks until closed" in {
       val start = Instant.now()
 
-      val ticker = Time.newTicker(Duration(10, TimeUnit.MILLISECONDS))
+      val ticker = TimeChannels.ticker(Duration(10, TimeUnit.MILLISECONDS))
 
       ticker.recv()
       val middle = Instant.now()
@@ -42,7 +42,7 @@ class TimeSuite extends AnyWordSpec {
     }
 
     "generate a ticker that ticks until closed111" in {
-      val ticker = Time.newTicker(Duration(10, TimeUnit.MILLISECONDS))
+      val ticker = TimeChannels.ticker(Duration(10, TimeUnit.MILLISECONDS))
 
       val start = Instant.now()
       ticker.close()
@@ -56,7 +56,7 @@ class TimeSuite extends AnyWordSpec {
     "generate a single shot read channel" in {
       val start = Instant.now()
 
-      val after = Time.after(Duration(10, TimeUnit.MILLISECONDS))
+      val after = TimeChannels.after(Duration(10, TimeUnit.MILLISECONDS))
 
       after.recv()
       val finish = Instant.now()