Twitter Util alternatives and similar packages
Based on the "Extensions" category.
Alternatively, view Twitter Util alternatives based on common mentions on social networks and blogs.
-
Enumeratum
A type-safe, reflection-free, powerful enumeration implementation for Scala with exhaustive pattern match warnings and helpful integrations. -
Scala Graph
Graph for Scala is intended to provide basic graph functionality seamlessly fitting into the Scala Collection Library. Like the well known members of scala.collection, Graph for Scala is an in-memory graph library aiming at editing and traversing graphs, finding cycles etc. in a user-friendly way. -
scribe
The fastest logging library in the world. Built from scratch in Scala and programmatically configurable. -
Rapture
DISCONTINUED. a collection of libraries for common, everyday programming tasks (I/O, JSON, i18n, etc.) -
Lamma
Lamma schedule generator for Scala is a professional schedule generation library for periodic schedules like fixed income coupon payment, equity deravitive fixing date generation etc. -
wvlet-log
DISCONTINUED. A library for enhancing your application logs with colors and source code locations. -
Resolvable
DISCONTINUED. A library to optimize fetching immutable data structures from several endpoints in several formats.
CodeRabbit: AI Code Reviews for Developers
* Code Quality Rankings and insights are calculated and provided by Lumnify.
They vary from L1 to L5 with "L5" being the highest.
Do you think we are missing an alternative of Twitter Util or a related project?
README
Twitter Util
A bunch of idiomatic, small, general purpose tools.
See the Scaladoc here or check out the user guide.
Status
This project is used in production at Twitter (and many other organizations), and is being actively developed and maintained.
Releases
Releases are done on an approximately monthly schedule. While semver is not followed, the [changelogs](CHANGELOG.rst) are detailed and include sections on public API breaks and changes in runtime behavior.
Contributing
We feel that a welcoming community is important and we ask that you follow Twitter's Open Source Code of Conduct in all interactions with the community.
The release
branch of this repository contains the latest stable release of
Util, and weekly snapshots are published to the develop
branch. In general
pull requests should be submitted against develop
. See
CONTRIBUTING.md
for more details about how to contribute.
Using in your project
An example SBT dependency string for the util-core
library would look like this:
val utilCore = "com.twitter" %% "util-core" % "22.7.0"
Units
Time
import com.twitter.conversions.DurationOps._
val duration1 = 1.second
val duration2 = 2.minutes
duration1.inMillis // => 1000L
Space
import com.twitter.conversions.StorageUnitOps._
val amount = 8.megabytes
amount.inBytes // => 8388608L
amount.inKilobytes // => 8192L
Futures
A Non-actor re-implementation of Scala Futures.
import com.twitter.conversions.DurationOps._
import com.twitter.util.{Await, Future, Promise}
val f = new Promise[Int]
val g = f.map { result => result + 1 }
f.setValue(1)
Await.result(g, 1.second) // => this blocks for the futures result (and eventually returns 2)
// Another option:
g.onSuccess { result =>
println(result) // => prints "2"
}
// Using for expressions:
val xFuture = Future(1)
val yFuture = Future(2)
for {
x <- xFuture
y <- yFuture
} {
println(x + y) // => prints "3"
}
Future interrupts
Method raise
on Future
(def raise(cause: Throwable)
) raises the interrupt described by
cause
to the producer of this Future
. Interrupt handlers are installed on a Promise
using setInterruptHandler
, which takes a partial function:
val p = new Promise[T]
p.setInterruptHandler {
case exc: MyException =>
// deal with interrupt..
}
Interrupts differ in semantics from cancellation in important ways: there can only be one interrupt handler per promise, and interrupts are only delivered if the promise is not yet complete.
Object Pool
The pool order is FIFO.
A pool of constants
import scala.collection.mutable
import com.twitter.util.{Await, SimplePool}
val queue = new mutable.Queue[Int] ++ List(1, 2, 3)
val pool = new SimplePool(queue)
// Note that the pool returns Futures, it doesn't block on exhaustion.
assert(Await.result(pool.reserve()) == 1)
pool.reserve().onSuccess { item =>
println(item) // prints "2"
}
A pool of dynamically created objects
Here is a pool of even-number generators. It stores 4 numbers at a time:
import com.twitter.util.{Future, FactoryPool}
val pool = new FactoryPool[Int](4) {
var count = 0
def makeItem() = { count += 1; Future(count) }
def isHealthy(i: Int) = i % 2 == 0
}
It checks the health when you successfully reserve an object (i.e., when the Future yields).
Hashing
util-hashing
is a collection of hash functions and hashing distributors (eg. ketama).
To use one of the available hash functions:
import com.twitter.hashing.KeyHasher
KeyHasher.FNV1_32.hashKey("string".getBytes)
Available hash functions are:
FNV1_32
FNV1A_32
FNV1_64
FNV1A_64
KETAMA
CRC32_ITU
HSIEH
To use KetamaDistributor
:
import com.twitter.hashing.{KetamaDistributor, KetamaNode, KeyHasher}
val nodes = List(KetamaNode("host:port", 1 /* weight */, "foo" /* handle */))
val distributor = new KetamaDistributor(nodes, 1 /* num reps */)
distributor.nodeForHash("abc".##) // => client
Time and Duration
Like arithmetic on doubles, Time
and Duration
arithmetic is now free of overflows. Instead, they overflow to Top
and Bottom
values, which are analogous to positive and negative infinity.
Since the resolution of Time.now
has been reduced (and is also more expensive due to its use of system time), a new Stopwatch
API has been introduced in order to calculate durations of time.
It's used simply:
import com.twitter.util.{Duration, Stopwatch}
val elapsed: () => Duration = Stopwatch.start()
which is read by applying elapsed
:
val duration: Duration = elapsed()
License
Copyright 2010 Twitter, Inc.
Licensed under the Apache License, Version 2.0: https://www.apache.org/licenses/LICENSE-2.0
*Note that all licence references and agreements mentioned in the Twitter Util README section above
are relevant to that project's source code only.