Simple FS2 interval implementation

interval.scala

import fs2._
import scala.concurrent.duration._

/**
 * Stream of signals with pauses
 */
object Interval {

  private implicit val strategy = Strategy.fromFixedDaemonPool(3)
  private implicit val scheduler = Scheduler.fromFixedDaemonPool(3)

  /**
   * Stream of actions with specified duration
   */
  def interval[A](task: Task[A], delay: FiniteDuration): Stream[Task, A] = {
    val delayedTask = task.schedule(delay)
    def go(newDelay: FiniteDuration): Stream[Task, A] = {
      Stream.eval(delayedTask) ++ go(delay)
    }

    go(delay)
  }

  /**
   * Pull durations
   */
  def unstableInterval(initial: Task[Int]): Stream[Task, Int] = {
    Stream.eval(initial).flatMap { duration =>
      val scheduled = Task.delay(duration).schedule(duration.seconds)
      Stream.eval(scheduled) ++ unstableInterval(initial)
    }
  }
}

/**
 * Outer object mock
 */
object DB {
  private var counter = 0

  def get: Task[Int] = {
    Task.delay {
      counter += 1 
      println(System.currentTimeMillis / 1000)
      counter
    }
  }
}

object Main extends App {
  Interval.interval(DB.get.map(println), 2.seconds).take(4).run.unsafeRun()
}