import com.evolutiongaming.catshelper.ClockHelper._
val clock = Clock.const[Id](nanos = 1000, millis = 2)
clock.millis // 2
clock.nanos // 1000
clock.micros // 1
clock.instant // Instant.ofEpochMilli(2)Provides a way to measure duration of a computation in a pure way.
Example:
import com.evolutiongaming.catshelper.MeasureDuration
for {
duration <- MeasureDuration[IO].start
_ <- doSomething
duration <- duration
} yield durationSyntax extensions are also available, allowing to measure duration of a computation and execute an effect with it:
import com.evolutiongaming.catshelper.syntax.measureDuration._
for {
int1 <- IO.pure(1).measured(elapsed => IO.println(s"elapsed: $elapsed"))
int2 <- IO.pure(1).measuredCase(
successF = elapsed => IO.println(s"Succeeded: $elapsed"),
failureF = elapsed => IO.println(s"Failed: $elapsed")
)
} yield int1 + int2Like Ref but allows A => F[A] rather than A => A
Ensures that updates are run serially
import com.evolutiongaming.catshelper.SerialRef
for {
ref <- SerialRef.of[IO, Int](0)
_ <- ref.update(a => (a + 1).pure[IO])
} yield {}Functional alternative to lazy keyword in Scala
trait LazyVal[F[_], A] {
def get: F[A]
def getLoaded: F[Option[A]]
}trait ToFuture[F[_]] {
def apply[A](fa: F[A]): Future[A]
}
trait FromFuture[F[_]] {
def apply[A](future: => Future[A]): F[A]
}trait ToTry[F[_]] {
def apply[A](fa: F[A]): Try[A]
}
trait FromTry[F[_]] {
def apply[A](fa: Try[A]): F[A]
}trait Log[F[_]] {
def debug(msg: => String): F[Unit]
def info(msg: => String): F[Unit]
def warn(msg: => String): F[Unit]
def warn(msg: => String, cause: Throwable): F[Unit]
def error(msg: => String): F[Unit]
def error(msg: => String, cause: Throwable): F[Unit]
}trait Runtime[F[_]] {
def availableCores: F[Int]
def freeMemory: F[Long]
def totalMemory: F[Long]
def maxMemory: F[Long]
def gc: F[Unit]
}trait ThreadLocalRef[F[_], A] {
def get: F[A]
def set(a: A): F[Unit]
def update(f: A => A): F[Unit]
def modify[B](f: A => (A, B)): F[B]
}This is useful to ensure release called at most once, in cases when "unsafe" api like Resource.allocated being used
val resource: Resource[F, A] = ???
resource.fencedA mutable reference to A value with read-write lock semantics.
Manages a given Resource[F, A] providing access to it only when a feature-toggle is on.
val serviceResource: Resource[F, AService] = ???
val flag: F[Boolean] = ???
val ftService: Resource[F, Resource[F, Option[AService]]] = FeatureToggled
.polling(
serviceResource,
flag,
pollInterval = 10.seconds,
gracePeriod = 30.seconds,
)
ftService.use { access =>
access.use {
case Some(service) => service.doStuff(…)
case None => F.unit
}
}This helper lives in a separate cats-helper-testkit module. It is makes testing F[_]-based code easier.
NOTE: cats-helper-testkit is an experimental module and may break SemVer guarantees from time to time.
However we will do our best to avoid unnecessary breakages.
"what time is it now?" in PureTest[IO].of { env =>
import env._
for {
_ <- IO.sleep(1.hour)
_ <- testRuntime.getTimeSinceStart.map(_ shouldBe 1.hour)
} yield ()
}addSbtPlugin("com.evolution" % "sbt-artifactory-plugin" % "0.0.2")
libraryDependencies += "com.evolutiongaming" %% "cats-helper" % "2.2.3"
React
Typescript
Django
Laravel
Facebook
Microsoft
Google
Alibaba
D3
Tencent