Scala
made by https://0x3d.site
GitHub - mockito/mockito-scala: Mockito for Scala languageMockito for Scala language. Contribute to mockito/mockito-scala development by creating an account on GitHub.
Visit Site
GitHub - mockito/mockito-scala: Mockito for Scala language
Mockito Scala
The most popular mocking framework for Java, now in Scala!!!
Why separate project?
The library has independent developers, release cycle and versioning from core mockito library (https://github.com/mockito/mockito). This is intentional because core Mockito developers don't use Scala and cannot confidently review PRs, and set the vision for the Scala library.
Dependency
- Artifact identifier: "org.mockito:mockito-scala_[scala-version]:[version]"
- Artifact identifier: "org.mockito:mockito-scala-scalatest_[scala-version]:[version]"
- Artifact identifier: "org.mockito:mockito-scala-specs2_[scala-version]:[version]"
- Artifact identifier: "org.mockito:mockito-scala-cats_[scala-version]:[version]"
- Artifact identifier: "org.mockito:mockito-scala-scalaz_[scala-version]:[version]"
- Latest version - see release notes
- Repositories: Maven Central
Please ensure you don't declare mockito-core
as a dependency. mockito-scala
will pull the appropriate version automatically
Note: For more examples and use cases than the ones shown below, please refer to the library's specific tests
Partial unification
If you're in Scala 2.11 or 2.12 you'll probably want to add the compiler flag -Ypartial-unification
, if you don't you risk some compile errors when trying to stub complex types using the idiomatic syntax
Notes for 1.13.6
We slightly changed the way one would expect no/no more interactions with a mock object in Expectations DSL.
From now on, expect (...) to
should only be used on stubbed methods, and can't express expectations about interactions with the mock objects itself.
In order to express expectations on a mock, one would use expect (...) on
(note the use of on
vs to
) where such expectations are supported.
- Instead of
expect no calls to aMock
, useexpect no calls on aMock
. - Instead of
expect noMore calls to aMock
, useexpect noMore calls on aMock
.
Expectations about no method calls stay the same: expect no calls to aMock.bar(*)
.
Notes for 1.13.0
We added a new experimental Expectations DSL for idiomatic syntax. It behaves differently from the original idiomatic verifications:
the user declares intent to verify by using expect
at the beginning of the line rather than at the end of it - similar to "verify" in Mockito Java.
Now, you can do expect a call to aMock.bar(*)
where previously you did aMock.bar(*) was called
. More examples in Expect DSL
Note that since this DSL is currently experimental, it's not stable - the DSL itself may evolve, components and base traits may move or be renamed, and incompatible changes may be introduced between minor/patch versions.
In order to use it...
- with Scalatest base traits, mix in
org.mockito.scalatest.IdiomaticMockitoBase with org.mockito.PrefixExpectations
instead oforg.mockito.scalatest.IdiomaticMockito
(ororg.mockito.scalatest.AsyncIdiomaticMockitoBase
) - with another test framework, mix in trait
org.mockito.IdiomaticMockito.WithExpect
or use its companion object
Notes for v1.4.0
As Specs2 support was added, now the library has been split in 3 different artifacts
- mockito-scala being the core
- mockito-scala-scalatest having specific classes that provide extra support for Scalatest
- mockito-scala-specs2 having specific classes that provide extra support for Specs2
From now on, when using the idiomatic syntax, you'll get any non-matcher parameter automatically wrapped in an eqTo
,
this means you shouldn't need to use it manually anymore. This is to provide a consistent behaviour when a custom scalactic.Equality
has been defined for
a type.
The traits that provide the specifics for each test framework are
- Scalatest:
org.mockito.scalatest.MockitoSugar
andorg.mockito.scalatest.IdiomaticMockito
for standard specsorg.mockito.scalatest.AsyncMockitoSugar
,org.mockito.scalatest.AsyncIdiomaticMockito
for async specs
- Specs2:
org.mockito.specs2.Mockito
This version also includes a lot of under-the-hood fixes and improvements that provide an even better experience.
Note for v1.2.0
As now the varargs support works consistently across the whole lib, no no special syntax is needed, so if you were using eqTo
with varargs, i.e.
verify(myObj).myMethod(eqTo("arg1", "arg2"))
You must change it now to
verify(myObj).myMethod(eqTo("arg1"), eqTo("arg2"))
Migration Notes for version 1.0.0
DefaultAnswer
was moved fromorg.mockito.DefaultAnswer
toorg.mockito.stubbing.DefaultAnswer
- The recommended way to use the pre-defined
DefaultAnswer
s is via the objectorg.mockito.DefaultAnswers
*
matcher is now defined inorg.mockito.ArgumentMatchersSugar
, mixin (or use the companion object) this trait whenever you wanna use itargumentCaptor[String]
was removed, replace byArgCaptor[T]
(Captor[T]
was renamed toArgCaptor[T]
to add clarity),ValCaptor[T]
was deprecated, (see Improved ArgumentCaptor)- The usage of
org.mockito.Answer[T]
was removed from the API in favour of Function Answers - If you were using something like
doAnswer(_ => <something>).when ...
to lazily compute a return value when the method is actually called you should now write it likedoAnswer(<something>).when ...
, no need of passing a function as that argument is by-name - If you have chained return values like
when(myMock.foo) thenReturn "a" thenReturn "b" etc...
the syntax has changed a bit towhen(myMock.foo) thenReturn "a" andThen "b" etc...
- Idiomatic syntax has some changes to remove postFix operations and also allow support for mixing values and argument matchers Mix-and-Match
aMock.bar shouldCallRealMethod => aMock.bar shouldCall realMethod
aMock wasCalled on bar => aMock.bar was called
aMock wasCalled onlyOn bar => aMock.bar wasCalled onlyHere
aMock was never called on bar => aMock.bar wasNever called
aMock wasCalled twiceOn bar => aMock.bar wasCalled twice
aMock wasCalled sixTimesOn bar => aMock.bar wasCalled sixTimes
aMock was never called => aMock.bar wasNever called
aMock was never called again => aMock.bar wasNever calledAgain
"mocked!" willBe returned by aMock bar => "mocked!" willBe returned by aMock.bar
"mocked!" willBe answered by aMock bar => "mocked!" willBe answered by aMock.bar
((i: Int) => i * 10) willBe answered by aMock bar * => ((i: Int) => i * 10) willBe answered by aMock.bar(*)
theRealMethod willBe called by aMock bar => theRealMethod willBe called by aMock.bar
new IllegalArgumentException willBe thrown by aMock bar => new IllegalArgumentException willBe thrown by aMock.bar
- eqToVal matcher syntax was improved to look more natural Value Class Matchers
NOTE:
eqToVal
has been deprecated in v 1.0.2 aseqTo
is now aware of value classes
verify(myObj).myMethod(eqToVal[MyValueClass](456)) => verify(myObj).myMethod(eqToVal(MyValueClass(456)))
myObj.myMethod(eqToVal[MyValueClass](456)) was called => myObj.myMethod(eqToVal(MyValueClass(456))) was called
Getting started
org.mockito.MockitoSugar
For a more detailed explanation read this
This trait wraps the API available on org.mockito.Mockito
from the Java version, but it provides a more Scala-like syntax, mainly
- Fixes the compiler errors that sometimes occurred when using overloaded methods that use varargs like doReturn
- Eliminates the need to use
classOf[T]
- Eliminates parenthesis when possible to make the test code more readable
- Adds
spyLambda[T]
to allow spying lambdas (they don't work with the standard spy as they are created as final classes by the compiler) - Supports mocking inline mixins like
mock[MyClass with MyTrait]
- Full support for by-name arguments (the full support was added in 1.4.0, before it was partial).
- Adds support for working with default arguments
The companion object also extends the trait to allow the usage of the API without mixing-in the trait in case that's desired
org.mockito.ArgumentMatchersSugar
For a more detailed explanation read this
This trait exposes all the existent org.mockito.ArgumentMatchers
but again it gives them a more Scala-like syntax, mainly
eq
was renamed toeqTo
to avoid clashing with the Scalaeq
operator for identity equality,eq
also supports value classes out of the box and relies onorg.scalactic.Equality[T]
(see Scalactic integration)any[T]
works even when the type can't be inferred, removing the need of using the likes ofanyString
,anyInt
, etc (see Notes)any[T]
also supports value classes (in this case you MUST provide the type parameter)isNull
andisNotNull
are deprecated as using nulls in Scala is clear code smell- Adds support for value classes via
anyVal[T]
andeqToVal[T]()
NOTE: both had been deprecated (useany[T]
oreqTo[T]
instead) - Adds
function0
to easily match for a function that returns a given value - Adds
argMatching
that takes a partial function to match, i.e.argMatching({ case Baz(_, "pepe") => })
Again, the companion object also extends the trait to allow the usage of the API without mixing-in the trait in case that's desired
Value Class Matchers
eqTo
and any[T]
support value classes since v1.0.2, so no special syntax is needed for them (but you MUST provide the type param for any[T]
otherwise you'll get a NPE)
Improved ArgumentCaptor
For a more detailed explanation read this
A new set of classes were added to make it easier, cleaner and more elegant to work with ArgumentCaptors, they also add support to capture value classes without any annoying syntax
There is a new object org.mockito.captor.ArgCaptor[T]
that exposes a nicer API
Before:
val aMock = mock[Foo]
val captor = argumentCaptor[String]
aMock.stringArgument("it worked!")
verify(aMock).stringArgument(captor.capture())
captor.getValue shouldBe "it worked!"
Now:
val aMock = mock[Foo]
val captor = ArgCaptor[String]
aMock.stringArgument("it worked!")
verify(aMock).stringArgument(captor)
captor hasCaptured "it worked!"
As you can see there is no need to call capture()
nor getValue
anymore (although they're still there if you need them as capture
and value
respectively)
The only scenario where you still have to call capture
by hand is where the argument you want to capture is Any
on the method signature, in that case the implicit
conversion that automatically does the capture
implicit def asCapture[T](c: Captor[T]): T = c.capture
is not called as the compiler finds no need to convert Captor[Any]
into Any
, as it is already an instance of Any
, given that Any
is the parent of every type in Scala. Because of that, the type does not need any transformation to be passed in.
There is another constructor ValCaptor[T]
that should be used to capture value classes
NOTE: Since version 1.0.2 ValCaptor[T]
has been deprecated as ArgCaptor[T]
now support both, standard and value classes
Both ArgCaptor[T]
and ValCaptor[T]
return an instance of Captor[T]
so the API is the same for both
org.mockito.MockitoScalaSession
Basic usage
This is a wrapper around org.mockito.MockitoSession
, it's main purpose (on top of having a Scala API)
is to improve the search of mis-used mocks and unexpected invocations to reduce debugging effort when something doesn't work
To use it just wrap your code with it, e.g.
MockitoScalaSession().run {
val foo = mock[Foo]
when(foo.bar("pepe")) thenReturn "mocked"
foo.bar("pepe") shouldBe "mocked"
}
That's it! that block of code will execute within a session which will take care of checking the use of the framework and, if the test fails, it will try to find out if the failure could be related to a mock being used incorrectly
Spies
Spies for partial mocking of real objects
"LinkedList size" should "return 100" in {
val spiedList = spy(new util.LinkedList[String])
when(spiedList.size).thenReturn(100)
assert(spiedList.size === 100)
}
Leniency
If for some reason we want that a mock created within the scope of a session does not report failures for some or all methods we can specify leniency for it.
For the whole mock or spy to be ignored by the session, so basically a mock/spy that behaves as if the session didn't exist at all, we can make it lenient, e.g.
val aMock = mock[Foo](withSettings.lenient())
val aSpy = spy(new Bar, lenient = true)
Now, if we just want to make one or more methods to be ignored by the session checks, we can make the method call lenient, this works as any other stubbing, so what it matters what matchers you define
aMock.myMethod(*) isLenient()
//or
when(aMock.myMethod(*)).isLenient()
Strict Mode
For a more detailed explanation read this
When using Scalatest and org.mockito.scalatest.IdiomaticMockito
this is the default mode, you can override the strictness to be lenient by doing val strictness: Strictness = Strictness.Lenient
The implication under the hood is that every test will run inside a MockitoScalaSession
, so all of them will run in Strict Stub mode.
org.mockito.scalatest.IdiomaticMockito
also includes org.mockito.IdiomaticMockito
and org.mockito.ArgumentMatchersSugar
so you have pretty much all
the mockito-scala API available in one go, i.e.
class MyTest extends WordSpec with IdiomaticMockito
IMPORTANT: A session is defined on a per-test basis, and only the mocks created within the scope of the session are handled by it, so if you have class level fields with mocks, i.e. mocks that are not created within the test, they will be ignored by the session. If you use the same mocks in all or most of the tests and want to avoid the boilerplate while still usfing the advantages of strict stubbing then declare those mocks in a setup trait.
class MySpec extends WordSpec with Mockito {
trait Setup {
val myMock = mock[Sth]
myMock.someMethod returns "something" /*stub common to **all** tests -notice that if it's not used by all of them then the session will find it as an unused stubbing on those-*/
}
"some feature" should {
"test whatever i want" in new Setup {
myMock.someOtherMethod(*) returns None /*stub specific only to this test*/
...test
}
"test something else" in new Setup {
myMock.someOtherMethod("expected value") returns Some("result") /*stub specific only to this test*/
...test
}
}
}
This will give you a fresh new instance of myMock
for each test but at the same time you only declare the creation/common stubbing once.
org.mockito.integrations.scalatest.ResetMocksAfterEachTest
| org.mockito.integrations.scalatest.ResetMocksAfterEachAsyncTest
Inspired by this StackOverflow question,
mockito-scala provides these traits that helps to automatically reset any existent mock after each test is run
The trait has to be mixed after org.mockito.MockitoSugar
in order to work, otherwise your test will not compile
The code shown in the StackOverflow question would look like this if using this mechanism
NOTE: MockitoFixture and ResetMocksAfterEachTest are mutually exclusive, so don't expect them to work together
class MyTest extends PlaySpec with MockitoSugar with ResetMocksAfterEachTest
private val foo = mock[Foo]
override def fakeApplication(): Application = new GuiceApplicationBuilder().overrides(bind[Foo].toInstance(foo)).build
The main advantage being we don't have to remember to reset each one of the mocks...
If for some reason we want to have a mock that is not reset automatically while using this trait, then it should be
created via the companion object of org.mockito.MockitoSugar
so is not tracked by this mechanism
Idiomatic Mockito
By adding the trait org.mockito.IdiomaticMockito
you get access to some improved methods in the API
This API is heavily inspired on Scalatest's Matchers, so if you have used them, you'll find it very familiar
Here we can see the old syntax on the left and the new one on the right
trait Foo {
def bar: String
def bar(v: Int): Int
}
val aMock = mock[Foo]
when(aMock.bar) thenReturn "mocked!" <=> aMock.bar returns "mocked!"
when(aMock.bar) thenReturn "mocked!" thenReturn "mocked again!" <=> aMock.bar returns "mocked!" andThen "mocked again!"
when(aMock.bar) thenCallRealMethod() <=> aMock.bar shouldCall realMethod
when(aMock.bar).thenThrow[IllegalArgumentException] <=> aMock.bar.shouldThrow[IllegalArgumentException]
when(aMock.bar) thenThrow new IllegalArgumentException <=> aMock.bar throws new IllegalArgumentException
when(aMock.bar) thenAnswer(_ => "mocked!") <=> aMock.bar answers "mocked!"
when(aMock.bar(any)) thenAnswer(_.getArgument[Int](0) * 10) <=> aMock.bar(*) answers ((i: Int) => i * 10)
doReturn("mocked!").when(aMock).bar <=> "mocked!" willBe returned by aMock.bar
doAnswer(_ => "mocked!").when(aMock).bar <=> "mocked!" willBe answered by aMock.bar
doAnswer(_.getArgument[Int](0) * 10).when(aMock).bar(any) <=> ((i: Int) => i * 10) willBe answered by aMock.bar(*)
doCallRealMethod.when(aMock).bar <=> theRealMethod willBe called by aMock.bar
doThrow(new IllegalArgumentException).when(aMock).bar <=> new IllegalArgumentException willBe thrown by aMock.bar
doNothing().when(aMock).bar <=> aMock.bar.doesNothing()
verifyZeroInteractions(aMock) <=> aMock wasNever called
verify(aMock).bar <=> aMock.bar was called
verify(aMock).bar(any) <=> aMock.bar(*) was called
verify(aMock, only).bar <=> aMock.bar wasCalled onlyHere
verify(aMock, never).bar <=> aMock.bar wasNever called
verify(aMock, times(2)).bar <=> aMock.bar wasCalled twice
verify(aMock, times(2)).bar <=> aMock.bar wasCalled 2.times
verify(aMock, times(6)).bar <=> aMock.bar wasCalled sixTimes
verify(aMock, times(6)).bar <=> aMock.bar wasCalled 6.times
verify(aMock, atLeast(6)).bar <=> aMock.bar wasCalled atLeastSixTimes
verify(aMock, atLeast(6)).bar <=> aMock.bar wasCalled atLeast(sixTimes)
verify(aMock, atLeast(6)).bar <=> aMock.bar wasCalled atLeast(6.times)
verify(aMock, atMost(6)).bar <=> aMock.bar wasCalled atMostSixTimes
verify(aMock, atMost(6)).bar <=> aMock.bar wasCalled atMost(sixTimes)
verify(aMock, atMost(6)).bar <=> aMock.bar wasCalled atMost(6.times)
verify(aMock, timeout(2000).atLeast(6)).bar <=> aMock.bar wasCalled (atLeastSixTimes within 2.seconds)
verifyNoMoreInteractions(aMock) <=> aMock wasNever calledAgain
val order = inOrder(mock1, mock2) <=> InOrder(mock1, mock2) { implicit order =>
order.verify(mock2).someMethod() <=> mock2.someMethod() was called
order.verify(mock1).anotherMethod() <=> mock1.anotherMethod() was called
<=> }
As you can see the new syntax reads a bit more natural, also notice you can use *
instead of any[T]
Check the tests for more examples
NOTE: When using the willBe syntax for stubbing, you can only stub one value to be returned, this is due to a limitation of the
type inference. If for some reason you have to do that (ideally all functions should be referentially transparent, so you wouldn't have to), you can
use the traditional syntax via the MockitoSugar companion object MockitoSugar.doReturn("meh").when(myMock).foo
or you
can use an answer that can decide what to return given whatever condition you need to simulate
{ (args) => if(<condition>) something else somethingElse } willBe answered by myMock.foo
Expect DSL
NOTE: This DSL is experimental, may be unstable and may introduce incompatible changes between minor/patch versions
This DSL is available as a prefix alternative to aMock.bar was called
DSL provided by Idiomatic Mockito
while keeping the original mocking and stubbing functionality. As you can see, with the new syntax you declare the
intent of verification before describing the called pattern, so it reads even more naturally then before.
It is available via org.mockito.IdiomaticMockito.WithExpect
mix-in (or its companion object). Mocking and stubbing works the same as before, and below are the examples of how verifications should be done.
trait Foo {
def bar: String
def bar(v: Int): Int
}
val aMock = mock[Foo]
verifyZeroInteractions(aMock) <=> expect no calls on aMock
verify(aMock).bar <=> expect a call to aMock.bar
verify(aMock).bar(any) <=> expect a call to aMock.bar(*)
verify(aMock, only).bar <=> expect only call to aMock.bar
verify(aMock, never).bar <=> expect no calls to aMock.bar
verify(aMock, times(2)).bar <=> expect exactly 2.calls to aMock.bar
verify(aMock, times(2)).bar <=> expect two calls to aMock.bar
verify(aMock, times(2)).bar <=> expect (2.calls) to aMock.bar
verify(aMock, times(6)).bar <=> expect exactly 6.calls to aMock.bar
verify(aMock, times(6)).bar <=> expect six calls to aMock.bar
verify(aMock, times(6)).bar <=> expect (6.calls) to aMock.bar
verify(aMock, atLeast(6)).bar <=> expect atLeast 6.calls to aMock.bar
verify(aMock, atLeast(6)).bar <=> expect atLeastSix calls to aMock.bar
verify(aMock, atMost(6)).bar <=> expect atMost 6.calls to aMock.bar
verify(aMock, atMost(6)).bar <=> expect atMostSix calls to aMock.bar
verify(aMock, timeout(2000).times(2)).bar <=> expect (2.calls within 2.seconds) to aMock.bar
verify(aMock, timeout(2000).atLeast(6)).bar <=> expect (atLeast(6.calls) within 2.seconds) to aMock.bar
verifyNoMoreInteractions(aMock) <=> expect noMore calls on aMock
verifyNoMoreInteractions(ignoreStubs(aMock)) <=> expect noMore calls(ignoringStubs) on aMock
val order = inOrder(mock1, mock2) <=> InOrder(mock1, mock2) { implicit order =>
order.verify(mock2).someMethod() <=> expect a call to mock2.someMethod()
order.verify(mock1).anotherMethod() <=> expect a call to mock1.anotherMethod()
<=> }
Default Answers
We defined a new type org.mockito.stubbing.DefaultAnswer
which is used to configure the default behaviour of a mock when a non-stubbed invocation
is made on it.
The object org.mockito.DefaultAnswers
contains each one of the provided ones
All the mocks created will use ReturnsSmartNulls
by default, this is different to the Java version, which returns null for any non-primitive or non-final class.
A "Smart Null", is nothing else than a mock of the type returned by the called method. The main advantage of doing that is that if the code tries to call any method on this mock, instead of failing with a NPE the mock will throw a different exception with a hint of the non-stubbed method that was called (including its params), this should make much easier the task of finding and fixing non-stubbed calls
Most of the Answers defined in org.mockito.Answers
have it's counterpart in org.mockito.DefaultAnswers
, and on top of that
we also provide ReturnsEmptyValues
which will try its best to return an empty object for well known types,
i.e. Nil
for List
, None
for Option
etc.
This DefaultAnswer is not part of the default behaviour as we think a SmartNull is better, to explain why, let's imagine we
have the following code.
class UserRepository {
def find(id: Int): Option[User]
}
class UserController(userRepository: UserRepository) {
def get(userId: Int): Option[Json] = userRepository.find(userId).map(_.toJson)
}
class UserControllerTest extends WordSpec with IdiomaticMockito {
"get" should {
"return the expected json" in {
val repo = mock[UserRepository]
val testObj = new UserController(repo)
testObj.get(123) shouldBe Some(Json(....)) //overly simplified for clarity
}
}
}
Now, in that example that test could fail in 3 different ways
- With the standard implementation of Mockito, the mock would return null and we would get a NullPointerException, which we all agree it's far from ideal, as it's hard to know where did it happen in non trivial code
- With the default/empty values, we would get a
None
, so the final result would beNone
and we will get an assertion error asNone
is notSome(Json(....))
, but I'm not sure how much improvement over the NPE this would be, because in a non-trivial method we may have many dependencies returningOption
and it could be hard to track down which one is returningNone
and why - With a smart-null, we would return a
mock[Option]
and as soon as our code calls to.map()
that mock would fail with an exception telling you what non-stubbed method was called and on which mock (in the example would say something you called thefind
method on somemock of type UserRepository
)
And that's why we use option 3 as default
Of course you can override the default behaviour, for this you have 2 options
- If you wanna do it just for a particular mock, you can, at creation time do
mock[MyType](MyDefaultAnswer)
- If you wanna do it for all the mocks in a test, you can define an
implicit
, i.e.implicit val defaultAnswer: DefaultAnswer = MyDefaultAnswer
DefaultAnswers are also composable, so for example if you wanted empty values first and then smart nulls you could do implicit val defaultAnswer: DefaultAnswer = ReturnsEmptyValues orElse ReturnsSmartNulls
Function Answers
org.mockito.Answer[T]
can be a bit boilerplate-ish, mostly if you're still in Scala 2.11 (in 2.12 with SAM is much nicer),
to simplify the usage for both versions is that we replaced it by standard scala functions, so instead of
when(myMock.foo("bar", 42)) thenAnswer new Answer[String] {
override def answer(invocation: InvocationOnMock): String = i.getArgument[String](0) + i.getArgument[Int](1)
}
We can now write: (this may be nothing new for users of 2.12, but at least now the API is consistent for both 2.11 and 2.12)
when(myMock.foo("bar", 42)) thenAnswer ((i: InvocationOnMock) => i.getArgument[String](0) + i.getArgument[Int](1))
I guess we all agree that's much better, but, it gets even better, we can now pass standard functions that work over the arguments, we only need to take care to pass the right types, so the previous example would become
when(myMock.foo("bar", 42)) thenAnswer ((v1: String, v2: Int) => v1 + v2)
Mix and match
Mixing normal values with argument matchers
Since mockito 1.0.0, when you use the idiomatic syntax, you are not forced anymore to use argument matchers for all your parameters as soon as you use one, so stuff like this is now valid (not a comprehensive list, just a bunch of examples)
trait Foo {
def bar(v: Int, v2: Int, v3: Int = 42): Int
}
val aMock = mock[Foo]
aMock.bar(1,2) returns "mocked!"
aMock.bar(1,*) returns "mocked!"
aMock.bar(*,*) returns "mocked!"
aMock.bar(*,*, 3) returns "mocked!"
"mocked!" willBe returned by aMock.bar(1,2)
"mocked!" willBe returned by aMock.bar(1,*)
"mocked!" willBe returned by aMock.bar(*,*)
"mocked!" willBe returned by aMock.bar(*,*, 3)
aMock.bar(1,2) was called
aMock.bar(1,*) was called
aMock.bar(*,*) was called
aMock.bar(*,*, 3) was called
So far there is one caveat, if you have a curried function that has default arguments on the second (or any following) argument list, the macro that achieves this will fail, this is related to how the default method is created by the compiler. I'll write a more detailed explanation at some point, but there are more than one reason why this is probably never going to work The workaround is quite easy though, just provide a value (or a matcher) for that argument and you are good to go.
Numeric matchers
A new set of matchers to deal with number comparison were introduced (see Scalactic tolerance for approximation), the syntax is slightly different to make them more readable, so now we can write stuff like (notice the 'n')
aMock.method(5)
aMock.method(n > 4.99) was called
aMock.method(n >= 5) was called
aMock.method(n < 5.1) was called
aMock.method(n <= 5) was called
Varargs
Most matchers that makes sense to, work with varargs out of the box, the only thing to notice is that if you are passing more than one value
and want to use eqTo
then you should pass all of them to the same instance of eqTo
e.g.
trait FooWithVarArgAndSecondParameterList {
def bar(bells: String*)(cheese: String): String
}
foo.bar(eqTo("cow", "blue"))(*) was called //RIGHT
foo.bar(eqTo("cow"), eqTo("blue"))(*) was called //WRONG - it will complain it was expecting 2 matchers but got 3
Scalactic integration
Equality
Since version 1.0.0 the eqTo
matcher uses the org.scalactic.Equality[T]
typeclass, this doesn't change anything on the API
and existent code will not be affected, but it allows you to override the standard equality of any class by just providing an
implicit Equality
in scope, e.g.
implicit val fooEquality: Equality[Foo] = new Equality[Foo] {
override def areEqual(a: Foo, b: Any): Boolean = /*Do the comparison as you like*/
}
aMock.method(eqTo(/*some foo instance/*))
Tolerance
You can use Scalactic's Spread[T]
to deal with the precision errors in floating points, so you can now write stuff like
aMock.method(4.999)
aMock.method(n =~ 5.0 +- 0.001) was called
Prettifier
An instance of org.scalactic.Prettifier
is implicitly pulled by the EqTo
matcher to provide a nicer (and customisable) printing of
your types when an verification fails. EqTo
is also used internally by Mockito
to print the arguments of every invocation, so you'll
get a consistent printing for both the expectation and the actual call.
If you want to customise the print of any type you just need to declare your Prettifier
in the implicit scope like
implicit val prettifier: Prettifier = new Prettifier {
override def apply(o: Any): String = o match {
case Baz2(_, s) => s"PrettifiedBaz($s)"
case other => Prettifier.default(other)
}
}
Cats integration
By adding the module mockito-scala-cats
2 new traits are available, IdiomaticMockitoCats
and MockitoCats
which are meant to be mixed-in in
tests that use IdiomaticMockito
and MockitoSugar
respectively.
Please look at the tests for more detailed examples
MockitoCats
This traits adds whenF()
which allows stubbing methods that return an Applicative (or an ApplicativeError) to be stubbed by just providing
the content of said applicative (or the error).
So for
trait Foo {
def returnsOption[T](v: T): Option[T]
def returnsMT[M[_], T](v: T): M[T]
}
// We can now write
val aMock = mock[Foo]
whenF(aMock.returnsOption(*)) thenReturn "mocked!"
whenF(aMock.returnsMT[Future, String](*)) thenReturn "mocked!"
// Rather than
when(aMock.returnsOption(*)) thenReturn Some("mocked!")
when(aMock.returnsMT[Future, String](*)) thenReturn Future.successful("mocked!")
//We could also do stubbings in a single line if that's all we need from the mock
val inlineMock: Foo = whenF(mock[Foo].returnsOption(*)) thenReturn "mocked!"
// For errors we can do
type ErrorOr[A] = Either[Error, A]
val failingMock: Foo = whenF(mock[Foo].returnsMT[ErrorOr, MyClass](*)) thenFailWith Error("error")
//Rather than
val failingMock: Foo = when(mock[Foo].returnsMT[ErrorOr, MyClass](*)) thenReturn Left(Error("error"))
The trait also provides and implicit conversion from cats.Eq
to scalactic.Equality
so if you have an implicit cats.Eq
instance in scope,
it will be automatically used by the eqTo
matcher.
IdiomaticMockitoCats
Similar to MockitoCats
but for the idiomatic syntax (including the conversion from cats.Eq
to scalactic.Equality
), so the code would look like
trait Foo {
def returnsOption[T](v: T): Option[T]
def returnsMT[M[_], T](v: T): M[T]
}
// We can now write
val aMock = mock[Foo]
aMock.returnsOption(*) returnsF "mocked!"
aMock.returnsMT[Future, String](*) returnsF "mocked!"
// Rather than
aMock.returnsOption(*) returns Some("mocked!")
aMock.returnsMT[Future, String](*) returns Future.successful("mocked!")
//We could also do stubbings in a single line if that's all we need from the mock
val inlineMock: Foo = mock[Foo].returnsOption(*) returnsF "mocked!"
// For errors we can do
type ErrorOr[A] = Either[Error, A]
val failingMock: Foo = mock[Foo].returnsMT[ErrorOr, MyClass](*) raises Error("error")
//Rather than
val failingMock: Foo = mock[Foo].returnsMT[ErrorOr, MyClass](*) returns Left(Error("error"))
Scalaz integration
By adding the module mockito-scala-scalaz
2 new traits are available, IdiomaticMockitoScalaz
and MockitoScalaz
which are meant to be mixed-in in
tests that use IdiomaticMockito
and MockitoSugar
respectively.
Please look at the tests for more detailed examples
MockitoScalaz
This traits adds whenF()
which allows stubbing methods that return an Applicative (or an ApplicativeError) to be stubbed by just providing
the content of said applicative (or the error).
So for
trait Foo {
def returnsOption[T](v: T): Option[T]
def returnsMT[M[_], T](v: T): M[T]
}
// We can now write
val aMock = mock[Foo]
whenF(aMock.returnsOption(*)) thenReturn "mocked!"
whenF(aMock.returnsMT[Future, String](*)) thenReturn "mocked!"
// Rather than
when(aMock.returnsOption(*)) thenReturn Some("mocked!")
when(aMock.returnsMT[Future, String](*)) thenReturn Future.successful("mocked!")
//We could also do stubbings in a single line if that's all we need from the mock
val inlineMock: Foo = whenF(mock[Foo].returnsOption(*)) thenReturn "mocked!"
// For errors we can do
type ErrorOr[A] = Either[Error, A]
val failingMock: Foo = whenF(mock[Foo].returnsMT[ErrorOr, MyClass](*)) thenFailWith Error("error")
//Rather than
val failingMock: Foo = when(mock[Foo].returnsMT[ErrorOr, MyClass](*)) thenReturn Left(Error("error"))
The trait also provides and implicit conversion from scalaz.Equal
to scalactic.Equality
so if you have an implicit scalaz.Equal
instance in scope,
it will be automatically used by the eqTo
matcher.
IdiomaticMockitoScalaz
Similar to MockitoScalaz
but for the idiomatic syntax (including the conversion from scalaz.Equal
to scalactic.Equality
), so the code would look like
trait Foo {
def returnsOption[T](v: T): Option[T]
def returnsMT[M[_], T](v: T): M[T]
}
// We can now write
val aMock = mock[Foo]
aMock.returnsOption(*) returnsF "mocked!"
aMock.returnsMT[Future, String](*) returnsF "mocked!"
// Rather than
aMock.returnsOption(*) returns Some("mocked!")
aMock.returnsMT[Future, String](*) returns Future.successful("mocked!")
//We could also do stubbings in a single line if that's all we need from the mock
val inlineMock: Foo = mock[Foo].returnsOption(*) returnsF "mocked!"
// For errors we can do
type ErrorOr[A] = Either[Error, A]
val failingMock: Foo = mock[Foo].returnsMT[ErrorOr, MyClass](*) raises Error("error")
//Rather than
val failingMock: Foo = mock[Foo].returnsMT[ErrorOr, MyClass](*) returns Left(Error("error"))
Mocking Scala object
Since version 1.16.0 it is possible to mock object
methods, given that such definitions are global, the way to mock them is slightly different in order to ensure we restore the real implementation of the object after we are done
To enable withObjectMocked
feature, it is mandatory to create the file src/test/resources/mockito-extensions/org.mockito.plugins.MockMaker
containing a single line:
mock-maker-inline
Example:
object FooObject {
def simpleMethod: String = "not mocked!"
}
"mock" should {
"stub an object method" in {
FooObject.simpleMethod shouldBe "not mocked!"
withObjectMocked[FooObject.type] {
FooObject.simpleMethod returns "mocked!"
//or
when(FooObject.simpleMethod) thenReturn "mocked!"
FooObject.simpleMethod shouldBe "mocked!"
}
FooObject.simpleMethod shouldBe "not mocked!"
}
}
As you can see, the effect of the mocking is only available inside the code block passed to withObjectMocked
, when such block ends the behavior of the object is restored to its original implementation
Notes
Dead code warning
if you have enabled the compiler flag -Ywarn-dead-code
, you will see the warning dead code following this construct
when using the any
or *
matchers , this is because in some cases the compiler can not infer the return type of those
matchers and it will default to Nothing
, and this compiler warning is shown every time Nothing
is found on our code.
This will NOT affect the behaviour of Mockito nor your test in any way, so it can be ignored, but in case you
want to get rid of it then you have 2 options:
- If you are not too fuss about dead code warnings in test code, you can add
scalacOptions in Test -= "-Ywarn-dead-code"
to your build.sbt and that warning will be ignored for your tests only - If you wanna keep the warning enabled for potentially real dead code statements, but get rid of the warnings related to the
matchers usage then you have to explicitly provide the type for the matcher, thus
any
would becomeany[MyType]
and*
would become*[MyType]
(you can also useanyShort
,anyInt
, etc for the primitive types)
Scala 2.11
Please note that in Scala 2.11 the following features are not supported
- Default arguments on methods defined in traits (they will behave as before, getting
null
or a default value if they are of a primitive type) - Any kind of
ArgumentMatcher[T]
for methods with by-name parameters (they'll throw an exception if used withArgumentMatcher[T]
)
Authors
- Bruno Bonanno - Initial work - bbonanno
License
This project is licensed under the MIT License - see the LICENSE file for details
More Resourcesto explore the angular.
mail [email protected] to add your project or resources here 🔥.
- 1A toolkit for servicing HTTP requests in Scala
https://github.com/unfiltered/unfiltered
A toolkit for servicing HTTP requests in Scala. Contribute to unfiltered/unfiltered development by creating an account on GitHub.
- 2A Scala DSL for talking with databases with minimum verbosity and maximum type safety
https://github.com/squeryl/squeryl
A Scala DSL for talking with databases with minimum verbosity and maximum type safety - squeryl/squeryl
- 3Apache Flink
https://github.com/apache/flink
Apache Flink. Contribute to apache/flink development by creating an account on GitHub.
- 4Vert.x for Scala
https://github.com/vert-x3/vertx-lang-scala
Vert.x for Scala. Contribute to vert-x3/vertx-lang-scala development by creating an account on GitHub.
- 5Chromaprint/AcoustID audio fingerprinting for the JVM
https://github.com/mgdigital/Chromaprint.scala
Chromaprint/AcoustID audio fingerprinting for the JVM - mgdigital/Chromaprint.scala
- 6A macro library that converts native imperative syntax to scalaz's monadic expressions
https://github.com/ThoughtWorksInc/each
A macro library that converts native imperative syntax to scalaz's monadic expressions - ThoughtWorksInc/each
- 7Incredibly simple DI Scala library.
https://github.com/yakivy/jam
Incredibly simple DI Scala library. Contribute to yakivy/jam development by creating an account on GitHub.
- 8Security library for Play framework 2 in Java and Scala: OAuth, CAS, SAML, OpenID Connect, LDAP, JWT...
https://github.com/pac4j/play-pac4j
Security library for Play framework 2 in Java and Scala: OAuth, CAS, SAML, OpenID Connect, LDAP, JWT... - pac4j/play-pac4j
- 9laserdisc-io/mysql-binlog-stream
https://github.com/laserdisc-io/mysql-binlog-stream
Contribute to laserdisc-io/mysql-binlog-stream development by creating an account on GitHub.
- 10GNU Gettext .po file loader for Scala
https://github.com/xitrum-framework/scaposer
GNU Gettext .po file loader for Scala. Contribute to xitrum-framework/scaposer development by creating an account on GitHub.
- 11Light-weight convenience wrapper around Lucene to simplify complex tasks and add Scala sugar.
https://github.com/outr/lucene4s
Light-weight convenience wrapper around Lucene to simplify complex tasks and add Scala sugar. - outr/lucene4s
- 12Workflow engine for exploration of simulation models using high throughput computing
https://github.com/openmole/openmole
Workflow engine for exploration of simulation models using high throughput computing - openmole/openmole
- 13PostgreSQL protocol support for Finagle
https://github.com/finagle/finagle-postgres
PostgreSQL protocol support for Finagle. Contribute to finagle/finagle-postgres development by creating an account on GitHub.
- 14Simple play module for authenticating against Google
https://github.com/guardian/play-googleauth
Simple play module for authenticating against Google - guardian/play-googleauth
- 15Extensible JOSE library for Scala
https://github.com/blackdoor/jose
Extensible JOSE library for Scala. Contribute to blackdoor/jose development by creating an account on GitHub.
- 16Large off-heap arrays and mmap files for Scala and Java
https://github.com/xerial/larray
Large off-heap arrays and mmap files for Scala and Java - xerial/larray
- 17A scala library for connecting to a redis server, or a cluster of redis nodes using consistent hashing on the client side.
https://github.com/debasishg/scala-redis
A scala library for connecting to a redis server, or a cluster of redis nodes using consistent hashing on the client side. - debasishg/scala-redis
- 18Idiomatic, typesafe, and reactive Scala client for Apache Pulsar
https://github.com/CleverCloud/pulsar4s
Idiomatic, typesafe, and reactive Scala client for Apache Pulsar - CleverCloud/pulsar4s
- 19Purely functional JSON parser and library in scala.
https://github.com/argonaut-io/argonaut
Purely functional JSON parser and library in scala. - argonaut-io/argonaut
- 20Modern Load Testing as Code
https://github.com/gatling/gatling
Modern Load Testing as Code. Contribute to gatling/gatling development by creating an account on GitHub.
- 21A Scala ORM library
https://github.com/kostaskougios/mapperdao
A Scala ORM library. Contribute to kostaskougios/mapperdao development by creating an account on GitHub.
- 22Docker containers for testing in scala
https://github.com/testcontainers/testcontainers-scala
Docker containers for testing in scala. Contribute to testcontainers/testcontainers-scala development by creating an account on GitHub.
- 23A scala diff/patch library for Json
https://github.com/gnieh/diffson
A scala diff/patch library for Json. Contribute to gnieh/diffson development by creating an account on GitHub.
- 24Testing tool in Scala for HTTP JSON API
https://github.com/agourlay/cornichon
Testing tool in Scala for HTTP JSON API. Contribute to agourlay/cornichon development by creating an account on GitHub.
- 25If you don't agree with the data
https://github.com/splink/veto
If you don't agree with the data. Contribute to splink/veto development by creating an account on GitHub.
- 26Software Specifications for Scala
https://github.com/etorreborre/specs2
Software Specifications for Scala. Contribute to etorreborre/specs2 development by creating an account on GitHub.
- 27The Couchbase Monorepo for JVM Clients: Java, Scala, io-core…
https://github.com/couchbase/couchbase-jvm-clients
The Couchbase Monorepo for JVM Clients: Java, Scala, io-core… - couchbase/couchbase-jvm-clients
- 28Salat is a simple serialization library for case classes.
https://github.com/salat/salat
Salat is a simple serialization library for case classes. - salat/salat
- 29Practical effect composition library based on abstract wrapping type and the free monad
https://github.com/ISCPIF/freedsl
Practical effect composition library based on abstract wrapping type and the free monad - ISCPIF/freedsl
- 30SevenZip library for Scala, easy to use.
https://github.com/gonearewe/SevenZ4S
SevenZip library for Scala, easy to use. . Contribute to gonearewe/SevenZ4S development by creating an account on GitHub.
- 31The super light testing library for Scala and Scala.js
https://github.com/monix/minitest
The super light testing library for Scala and Scala.js - monix/minitest
- 32A module that provides OAuth, OAuth2 and OpenID authentication for Play Framework applications
https://github.com/jaliss/securesocial
A module that provides OAuth, OAuth2 and OpenID authentication for Play Framework applications - jaliss/securesocial
- 33Compile-time Language Integrated Queries for Scala
https://github.com/zio/zio-quill
Compile-time Language Integrated Queries for Scala - zio/zio-quill
- 34Scala Scripting
https://github.com/com-lihaoyi/Ammonite
Scala Scripting. Contribute to com-lihaoyi/Ammonite development by creating an account on GitHub.
- 35Slick (Scala Language Integrated Connection Kit) is a modern database query and access library for Scala
https://github.com/slick/slick
Slick (Scala Language Integrated Connection Kit) is a modern database query and access library for Scala - slick/slick
- 36Property-based testing for Scala
https://github.com/typelevel/scalacheck
Property-based testing for Scala. Contribute to typelevel/scalacheck development by creating an account on GitHub.
- 37Simpler DynamoDB access for Scala
https://github.com/scanamo/scanamo
Simpler DynamoDB access for Scala. Contribute to scanamo/scanamo development by creating an account on GitHub.
- 38Type-Safe framework for defining, modifying, and querying SQL databases
https://github.com/outr/scalarelational
Type-Safe framework for defining, modifying, and querying SQL databases - outr/scalarelational
- 39ScalaFX simplifies creation of JavaFX-based user interfaces in Scala
https://github.com/scalafx/scalafx
ScalaFX simplifies creation of JavaFX-based user interfaces in Scala - scalafx/scalafx
- 40Performant database access in Scala
https://github.com/lucidsoftware/relate
Performant database access in Scala. Contribute to lucidsoftware/relate development by creating an account on GitHub.
- 41Scala library for boilerplate-free validation
https://github.com/krzemin/octopus
Scala library for boilerplate-free validation. Contribute to krzemin/octopus development by creating an account on GitHub.
- 42Connect a Scala REPL to running JVM processes without any prior setup
https://github.com/xitrum-framework/scalive
Connect a Scala REPL to running JVM processes without any prior setup - xitrum-framework/scalive
- 43A ZIO-based redis client
https://github.com/zio/zio-redis
A ZIO-based redis client. Contribute to zio/zio-redis development by creating an account on GitHub.
- 44Tiny Scala high-performance, async web framework, inspired by Sinatra
https://github.com/scalatra/scalatra
Tiny Scala high-performance, async web framework, inspired by Sinatra - scalatra/scalatra
- 45Reactive data-binding for Scala
https://github.com/ThoughtWorksInc/Binding.scala
Reactive data-binding for Scala. Contribute to ThoughtWorksInc/Binding.scala development by creating an account on GitHub.
- 46The Anorm database library
https://github.com/playframework/anorm
The Anorm database library. Contribute to playframework/anorm development by creating an account on GitHub.
- 47A module for the Play Framework to build highly modular applications
https://github.com/splink/pagelets
A module for the Play Framework to build highly modular applications - splink/pagelets
- 48I/O and Microservice library for Scala
https://github.com/tumblr/colossus
I/O and Microservice library for Scala. Contribute to tumblr/colossus development by creating an account on GitHub.
- 49Scala library to sign HTTP requests to AWS services.
https://github.com/ticofab/aws-request-signer
Scala library to sign HTTP requests to AWS services. - ticofab/aws-request-signer
- 50Next generation user interface and application development in Scala and Scala.js for web, mobile, and desktop.
https://github.com/outr/youi
Next generation user interface and application development in Scala and Scala.js for web, mobile, and desktop. - outr/youi
- 51Statistical Machine Intelligence & Learning Engine
https://github.com/haifengl/smile
Statistical Machine Intelligence & Learning Engine - haifengl/smile
- 52Microbenchmarking and performance regression testing framework for the JVM platform.
https://github.com/scalameter/scalameter
Microbenchmarking and performance regression testing framework for the JVM platform. - scalameter/scalameter
- 53A testing tool for Scala and Java developers
https://github.com/scalatest/scalatest
A testing tool for Scala and Java developers. Contribute to scalatest/scalatest development by creating an account on GitHub.
- 54:monorail: "Scala on Rails" - A full-stack web app framework for rapid development in Scala
https://github.com/skinny-framework/skinny-framework
:monorail: "Scala on Rails" - A full-stack web app framework for rapid development in Scala - skinny-framework/skinny-framework
- 55Molecule translates custom Scala code to database queries for multiple databases.
https://github.com/scalamolecule/molecule
Molecule translates custom Scala code to database queries for multiple databases. - scalamolecule/molecule
- 56Cryptographic primitives for Scala
https://github.com/input-output-hk/scrypto
Cryptographic primitives for Scala. Contribute to input-output-hk/scrypto development by creating an account on GitHub.
- 57A lightweight framework for writing REST services in Scala.
https://github.com/mesosphere/chaos
A lightweight framework for writing REST services in Scala. - mesosphere/chaos
- 58Async and clustered Scala web framework and HTTP(S) server
https://github.com/xitrum-framework/xitrum
Async and clustered Scala web framework and HTTP(S) server - xitrum-framework/xitrum
- 59A distributed tracing extension for Akka. Provides integration with Play framework, Spray and Akka HTTP.
https://github.com/levkhomich/akka-tracing
A distributed tracing extension for Akka. Provides integration with Play framework, Spray and Akka HTTP. - levkhomich/akka-tracing
- 60A simple FRP library and a web UI framework built on it
https://github.com/nafg/reactive
A simple FRP library and a web UI framework built on it - nafg/reactive
- 61Facebook's React on Scala.JS
https://github.com/japgolly/scalajs-react
Facebook's React on Scala.JS. Contribute to japgolly/scalajs-react development by creating an account on GitHub.
- 62Figaro Programming Language and Core Libraries
https://github.com/charles-river-analytics/figaro
Figaro Programming Language and Core Libraries. Contribute to charles-river-analytics/figaro development by creating an account on GitHub.
- 63Optimus is a mathematical programming library for Scala.
https://github.com/vagmcs/Optimus
Optimus is a mathematical programming library for Scala. - vagmcs/Optimus
- 64Fast JSON parser/generator for Scala
https://github.com/gzoller/ScalaJack
Fast JSON parser/generator for Scala. Contribute to gzoller/ScalaJack development by creating an account on GitHub.
- 65Apache Spark - A unified analytics engine for large-scale data processing
https://github.com/apache/spark
Apache Spark - A unified analytics engine for large-scale data processing - apache/spark
- 66scala SQL api
https://github.com/wangzaixiang/scala-sql
scala SQL api. Contribute to wangzaixiang/scala-sql development by creating an account on GitHub.
- 67Scala support library for integrating the JSON API spec with Spray, Play! or Circe
https://github.com/scala-jsonapi/scala-jsonapi
Scala support library for integrating the JSON API spec with Spray, Play! or Circe - scala-jsonapi/scala-jsonapi
- 68Scala code generator for Avro schemas.
https://github.com/malcolmgreaves/avro-codegen
Scala code generator for Avro schemas. Contribute to malcolmgreaves/avro-codegen development by creating an account on GitHub.
- 69Protocol buffer compiler for Scala.
https://github.com/scalapb/ScalaPB
Protocol buffer compiler for Scala. Contribute to scalapb/ScalaPB development by creating an account on GitHub.
- 70Functional JDBC layer for Scala.
https://github.com/tpolecat/doobie
Functional JDBC layer for Scala. Contribute to tpolecat/doobie development by creating an account on GitHub.
- 71CPU and GPU-accelerated Machine Learning Library
https://github.com/BIDData/BIDMach
CPU and GPU-accelerated Machine Learning Library. Contribute to BIDData/BIDMach development by creating an account on GitHub.
- 72Graph 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.
https://github.com/scala-graph/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-memo...
- 73Axle Domain Specific Language for Scientific Cloud Computing and Visualization
https://github.com/axlelang/axle
Axle Domain Specific Language for Scientific Cloud Computing and Visualization - axlelang/axle
- 74Lightweight and fast serialization library for Scala 2/3 based on Protocol Buffers with macros
https://github.com/zero-deps/proto
Lightweight and fast serialization library for Scala 2/3 based on Protocol Buffers with macros - zero-deps/proto
- 75Scala Uniquely Bound Classes Under Traits
https://github.com/dickwall/subcut
Scala Uniquely Bound Classes Under Traits. Contribute to dickwall/subcut development by creating an account on GitHub.
- 76Highly available distributed strong eventual consistent and sequentially consistent storage with feeds, sorting and search
https://github.com/zero-deps/kvs
Highly available distributed strong eventual consistent and sequentially consistent storage with feeds, sorting and search - zero-deps/kvs
- 77Single Page Applications running on the server side.
https://github.com/fomkin/korolev
Single Page Applications running on the server side. - fomkin/korolev
- 78A foundational framework for distributed programming.
https://github.com/reactors-io/reactors
A foundational framework for distributed programming. - reactors-io/reactors
- 79A dimensional analysis library based on dependent types
https://github.com/to-ithaca/libra
A dimensional analysis library based on dependent types - to-ithaca/libra
- 80CSV handling library for Scala
https://github.com/nrinaudo/kantan.csv
CSV handling library for Scala. Contribute to nrinaudo/kantan.csv development by creating an account on GitHub.
- 81MessagePack serializer implementation for Scala / msgpack.org[Scala]
https://github.com/msgpack/msgpack-scala
MessagePack serializer implementation for Scala / msgpack.org[Scala] - msgpack/msgpack-scala
- 82uPickle: a simple, fast, dependency-free JSON & Binary (MessagePack) serialization library for Scala
https://github.com/com-lihaoyi/upickle
uPickle: a simple, fast, dependency-free JSON & Binary (MessagePack) serialization library for Scala - com-lihaoyi/upickle
- 83a simple Scala CLI parsing library
https://github.com/scallop/scallop
a simple Scala CLI parsing library. Contribute to scallop/scallop development by creating an account on GitHub.
- 84Add-on module for Jackson (https://github.com/FasterXML/jackson) to support Scala-specific datatypes
https://github.com/FasterXML/jackson-module-scala
Add-on module for Jackson (https://github.com/FasterXML/jackson) to support Scala-specific datatypes - FasterXML/jackson-module-scala
- 85Type-safe data migration tool for Slick, Git and beyond.
https://github.com/lastland/scala-forklift
Type-safe data migration tool for Slick, Git and beyond. - lastland/scala-forklift
- 86A tidy SQL-based DB access library for Scala developers. This library naturally wraps JDBC APIs and provides you easy-to-use APIs.
https://github.com/scalikejdbc/scalikejdbc
A tidy SQL-based DB access library for Scala developers. This library naturally wraps JDBC APIs and provides you easy-to-use APIs. - scalikejdbc/scalikejdbc
- 87Scala compiler plugin that acts like GNU xgettext command to extract i18n strings in Scala source code files to Gettext .po file
https://github.com/xitrum-framework/scala-xgettext
Scala compiler plugin that acts like GNU xgettext command to extract i18n strings in Scala source code files to Gettext .po file - xitrum-framework/scala-xgettext
- 88REScala - distributed and reactive programming embedded in OO and FP programs.
https://github.com/rescala-lang/REScala
REScala - distributed and reactive programming embedded in OO and FP programs. - rescala-lang/REScala
- 89Scala classpath scanner
https://github.com/xitrum-framework/sclasner
Scala classpath scanner. Contribute to xitrum-framework/sclasner development by creating an account on GitHub.
- 90Iteratees for Cats
https://github.com/travisbrown/iteratee
Iteratees for Cats. Contribute to travisbrown/iteratee development by creating an account on GitHub.
- 91Fast, secure JSON library with tight ZIO integration.
https://github.com/zio/zio-json
Fast, secure JSON library with tight ZIO integration. - zio/zio-json
- 92Schema registry for CSV, TSV, JSON, AVRO and Parquet schema. Supports schema inference and GraphQL API.
https://github.com/indix/schemer
Schema registry for CSV, TSV, JSON, AVRO and Parquet schema. Supports schema inference and GraphQL API. - indix/schemer
- 93Play2.x Authentication and Authorization module
https://github.com/t2v/play2-auth
Play2.x Authentication and Authorization module. Contribute to t2v/play2-auth development by creating an account on GitHub.
- 94Jawn is for parsing jay-sawn (JSON)
https://github.com/typelevel/jawn
Jawn is for parsing jay-sawn (JSON). Contribute to typelevel/jawn development by creating an account on GitHub.
- 95An ONNX (Open Neural Network eXchange) API and backend for typeful, functional deep learning and classical machine learning in Scala 3
https://github.com/EmergentOrder/onnx-scala
An ONNX (Open Neural Network eXchange) API and backend for typeful, functional deep learning and classical machine learning in Scala 3 - EmergentOrder/onnx-scala
- 96Labeled records for Scala based on structural refinement types and macros.
https://github.com/scala-records/scala-records
Labeled records for Scala based on structural refinement types and macros. - scala-records/scala-records
- 97Breeze is a numerical processing library for Scala.
https://github.com/scalanlp/breeze
Breeze is a numerical processing library for Scala. - scalanlp/breeze
- 98Scala Library for Reading Flat File Data (CSV/TSV/XLS/XLSX)
https://github.com/frugalmechanic/fm-flatfile
Scala Library for Reading Flat File Data (CSV/TSV/XLS/XLSX) - frugalmechanic/fm-flatfile
- 99Platform to build distributed, scalable, enterprise-wide business applications
https://github.com/annetteplatform/annette
Platform to build distributed, scalable, enterprise-wide business applications - annetteplatform/annette
- 100Cassovary is a simple big graph processing library for the JVM
https://github.com/twitter/cassovary
Cassovary is a simple big graph processing library for the JVM - twitter/cassovary
- 101A concurrent reactive programming framework.
https://github.com/storm-enroute/reactors
A concurrent reactive programming framework. Contribute to storm-enroute/reactors development by creating an account on GitHub.
- 102Library to register and lookup actors by names in an Akka cluster
https://github.com/xitrum-framework/glokka
Library to register and lookup actors by names in an Akka cluster - xitrum-framework/glokka
- 103:cake: doddle-model: machine learning in Scala.
https://github.com/picnicml/doddle-model
:cake: doddle-model: machine learning in Scala. Contribute to picnicml/doddle-model development by creating an account on GitHub.
- 104A Scala API for Apache Beam and Google Cloud Dataflow.
https://github.com/spotify/scio
A Scala API for Apache Beam and Google Cloud Dataflow. - spotify/scio
- 105A mini Scala utility library
https://github.com/scala-hamsters/hamsters
A mini Scala utility library. Contribute to scala-hamsters/hamsters development by creating an account on GitHub.
- 106Powerful new number types and numeric abstractions for Scala.
https://github.com/typelevel/spire
Powerful new number types and numeric abstractions for Scala. - typelevel/spire
- 107A Persistence Framework for Scala and NoSQL
https://github.com/longevityframework/longevity
A Persistence Framework for Scala and NoSQL. Contribute to longevityframework/longevity development by creating an account on GitHub.
- 108Async lightweight Scala web framework
https://github.com/dvarelap/peregrine
Async lightweight Scala web framework. Contribute to dvarelap/peregrine development by creating an account on GitHub.
- 109CSV Reader/Writer for Scala
https://github.com/tototoshi/scala-csv
CSV Reader/Writer for Scala. Contribute to tototoshi/scala-csv development by creating an account on GitHub.
- 110A Thrift parser/generator
https://github.com/twitter/scrooge
A Thrift parser/generator. Contribute to twitter/scrooge development by creating an account on GitHub.
- 111N-dimensional / multi-dimensional arrays (tensors) in Scala 3. Think NumPy ndarray / PyTorch Tensor but type-safe over shapes, array/axis labels & numeric data types
https://github.com/SciScala/NDScala
N-dimensional / multi-dimensional arrays (tensors) in Scala 3. Think NumPy ndarray / PyTorch Tensor but type-safe over shapes, array/axis labels & numeric data types - SciScala/NDScala
- 112A JSR-310 port of nscala_time
https://github.com/chronoscala/chronoscala
A JSR-310 port of nscala_time. Contribute to chronoscala/chronoscala development by creating an account on GitHub.
- 113Lightweight Scala Dependency Injection Library
https://github.com/scaldi/scaldi
Lightweight Scala Dependency Injection Library. Contribute to scaldi/scaldi development by creating an account on GitHub.
- 114A fault tolerant, protocol-agnostic RPC system
https://github.com/twitter/finagle
A fault tolerant, protocol-agnostic RPC system. Contribute to twitter/finagle development by creating an account on GitHub.
- 115Scala library for accessing various file, batch systems, job schedulers and grid middlewares.
https://github.com/openmole/gridscale
Scala library for accessing various file, batch systems, job schedulers and grid middlewares. - openmole/gridscale
- 116JVM - Java, Kotlin, Scala image processing library
https://github.com/sksamuel/scrimage
JVM - Java, Kotlin, Scala image processing library - sksamuel/scrimage
- 117A group of neural-network libraries for functional and mainstream languages
https://github.com/mrdimosthenis/Synapses
A group of neural-network libraries for functional and mainstream languages - mrdimosthenis/Synapses
- 118Alpakka Kafka connector - Alpakka is a Reactive Enterprise Integration library for Java and Scala, based on Reactive Streams and Akka.
https://github.com/akka/alpakka-kafka
Alpakka Kafka connector - Alpakka is a Reactive Enterprise Integration library for Java and Scala, based on Reactive Streams and Akka. - akka/alpakka-kafka
- 119Productivity-oriented collection of lightweight fancy stuff for Scala toolchain
https://github.com/7mind/izumi
Productivity-oriented collection of lightweight fancy stuff for Scala toolchain - 7mind/izumi
- 120Real Time Analytics and Data Pipelines based on Spark Streaming
https://github.com/Stratio/sparta
Real Time Analytics and Data Pipelines based on Spark Streaming - Stratio/sparta
- 121C4E, a JVM friendly library written in Scala for both local and distributed (Spark) Clustering.
https://github.com/Clustering4Ever/Clustering4Ever
C4E, a JVM friendly library written in Scala for both local and distributed (Spark) Clustering. - Clustering4Ever/Clustering4Ever
- 122Scala extensions for Google Guice
https://github.com/codingwell/scala-guice
Scala extensions for Google Guice. Contribute to codingwell/scala-guice development by creating an account on GitHub.
- 123Purely functional genetic algorithms for multi-objective optimisation
https://github.com/openmole/mgo
Purely functional genetic algorithms for multi-objective optimisation - openmole/mgo
- 124A composable command-line parser for Scala.
https://github.com/bkirwi/decline
A composable command-line parser for Scala. Contribute to bkirwi/decline development by creating an account on GitHub.
- 125ABANDONED Pure Scala serialization library with annotations
https://github.com/fomkin/pushka
ABANDONED Pure Scala serialization library with annotations - fomkin/pushka
- 126Modify deeply nested case class fields
https://github.com/softwaremill/quicklens
Modify deeply nested case class fields. Contribute to softwaremill/quicklens development by creating an account on GitHub.
- 127Non-blocking, ultra-fast Scala Redis client built on top of Akka IO, used in production at Livestream
https://github.com/Livestream/scredis
Non-blocking, ultra-fast Scala Redis client built on top of Akka IO, used in production at Livestream - Livestream/scredis
- 128RxScala – Reactive Extensions for Scala – a library for composing asynchronous and event-based programs using observable sequences
https://github.com/ReactiveX/RxScala
RxScala – Reactive Extensions for Scala – a library for composing asynchronous and event-based programs using observable sequences - ReactiveX/RxScala
- 129Asynchronous, Reactive Programming for Scala and Scala.js.
https://github.com/monix/monix
Asynchronous, Reactive Programming for Scala and Scala.js. - monix/monix
- 130Easy way to create Free Monad using Scala macros with first-class Intellij support.
https://github.com/Thangiee/Freasy-Monad
Easy way to create Free Monad using Scala macros with first-class Intellij support. - Thangiee/Freasy-Monad
- 131Eff monad for cats - https://atnos-org.github.io/eff
https://github.com/atnos-org/eff
Eff monad for cats - https://atnos-org.github.io/eff - atnos-org/eff
- 132The missing MatPlotLib for Scala + Spark
https://github.com/vegas-viz/Vegas
The missing MatPlotLib for Scala + Spark. Contribute to vegas-viz/Vegas development by creating an account on GitHub.
- 133Scala extensions for the Kryo serialization library
https://github.com/twitter/chill
Scala extensions for the Kryo serialization library - twitter/chill
- 134Minimal, type-safe RPC Scala library.
https://github.com/yakivy/poppet
Minimal, type-safe RPC Scala library. Contribute to yakivy/poppet development by creating an account on GitHub.
- 135Reactive Microservices for the JVM
https://github.com/lagom/lagom
Reactive Microservices for the JVM. Contribute to lagom/lagom development by creating an account on GitHub.
- 136A scala extension for Project Reactor's Flux and Mono
https://github.com/spring-attic/reactor-scala-extensions
A scala extension for Project Reactor's Flux and Mono - spring-attic/reactor-scala-extensions
- 137Scala testing library with actionable errors and extensible APIs
https://github.com/scalameta/munit
Scala testing library with actionable errors and extensible APIs - scalameta/munit
- 138Scala wrapper for SnakeYAML
https://github.com/jcazevedo/moultingyaml
Scala wrapper for SnakeYAML. Contribute to jcazevedo/moultingyaml development by creating an account on GitHub.
- 139SynapseGrid is a framework for constructing dynamic low latency data flow systems.
https://github.com/Primetalk/SynapseGrid
SynapseGrid is a framework for constructing dynamic low latency data flow systems. - Primetalk/SynapseGrid
- 140Distributed NoSQL Database
https://github.com/stephenmcd/curiodb
Distributed NoSQL Database. Contribute to stephenmcd/curiodb development by creating an account on GitHub.
- 141Abstract Algebra for Scala
https://github.com/twitter/algebird
Abstract Algebra for Scala. Contribute to twitter/algebird development by creating an account on GitHub.
- 142Spark package to "plug" holes in data using SQL based rules ⚡️ 🔌
https://github.com/indix/sparkplug
Spark package to "plug" holes in data using SQL based rules ⚡️ 🔌 - GitHub - indix/sparkplug: Spark package to "plug" holes in data using SQL based rules ⚡️ 🔌
- 143A simple testing framework for Scala
https://github.com/com-lihaoyi/utest
A simple testing framework for Scala. Contribute to com-lihaoyi/utest development by creating an account on GitHub.
- 144Scalable Image Analysis and Shape Modelling
https://github.com/unibas-gravis/scalismo
Scalable Image Analysis and Shape Modelling. Contribute to unibas-gravis/scalismo development by creating an account on GitHub.
- 145Web-based notebook that enables data-driven, interactive data analytics and collaborative documents with SQL, Scala and more.
https://github.com/apache/zeppelin
Web-based notebook that enables data-driven, interactive data analytics and collaborative documents with SQL, Scala and more. - apache/zeppelin
- 146Mutation testing for Scala
https://github.com/stryker-mutator/stryker4s
Mutation testing for Scala. Contribute to stryker-mutator/stryker4s development by creating an account on GitHub.
- 147Streaming MapReduce with Scalding and Storm
https://github.com/twitter/summingbird
Streaming MapReduce with Scalding and Storm. Contribute to twitter/summingbird development by creating an account on GitHub.
- 148A library that toggles Scala code at compile-time, like #if in C/C++
https://github.com/ThoughtWorksInc/enableIf.scala
A library that toggles Scala code at compile-time, like #if in C/C++ - ThoughtWorksInc/enableIf.scala
- 149Casbah is now officially end-of-life (EOL).
https://github.com/mongodb/casbah
Casbah is now officially end-of-life (EOL). Contribute to mongodb/casbah development by creating an account on GitHub.
- 150Build highly concurrent, distributed, and resilient message-driven applications on the JVM
https://github.com/akka/akka
Build highly concurrent, distributed, and resilient message-driven applications on the JVM - akka/akka
- 151A framework to create embedded Domain-Specific Languages in Scala
https://github.com/ThoughtWorksInc/Dsl.scala
A framework to create embedded Domain-Specific Languages in Scala - ThoughtWorksInc/Dsl.scala
- 152Scala library for boilerplate-free, type-safe data transformations
https://github.com/scalalandio/chimney
Scala library for boilerplate-free, type-safe data transformations - scalalandio/chimney
- 153Interactive and Reactive Data Science using Scala and Spark.
https://github.com/spark-notebook/spark-notebook
Interactive and Reactive Data Science using Scala and Spark. - spark-notebook/spark-notebook
- 154TensorFlow API for the Scala Programming Language
https://github.com/eaplatanios/tensorflow_scala
TensorFlow API for the Scala Programming Language. Contribute to eaplatanios/tensorflow_scala development by creating an account on GitHub.
- 155numsca is numpy for scala
https://github.com/botkop/numsca
numsca is numpy for scala. Contribute to botkop/numsca development by creating an account on GitHub.
- 156A cohesive & pragmatic framework of FP centric Scala libraries
https://github.com/frees-io/freestyle
A cohesive & pragmatic framework of FP centric Scala libraries - frees-io/freestyle
- 157Build software better, together
https://github.com/Sciss/ScalaCollider
GitHub is where people build software. More than 100 million people use GitHub to discover, fork, and contribute to over 420 million projects.
- 158A lightweight, clean and simple JSON implementation in Scala
https://github.com/spray/spray-json
A lightweight, clean and simple JSON implementation in Scala - spray/spray-json
- 159A new Scala wrapper for Joda Time based on scala-time
https://github.com/nscala-time/nscala-time
A new Scala wrapper for Joda Time based on scala-time - nscala-time/nscala-time
- 160Convenient and performant logging library for Scala wrapping SLF4J.
https://github.com/lightbend-labs/scala-logging
Convenient and performant logging library for Scala wrapping SLF4J. - lightbend-labs/scala-logging
- 161Blindsight is a Scala logging API with DSL based structured logging, fluent logging, semantic logging, flow logging, and context aware logging.
https://github.com/tersesystems/blindsight
Blindsight is a Scala logging API with DSL based structured logging, fluent logging, semantic logging, flow logging, and context aware logging. - tersesystems/blindsight
- 162Command Line Interface Scala Toolkit
https://github.com/backuity/clist
Command Line Interface Scala Toolkit. Contribute to backuity/clist development by creating an account on GitHub.
- 163command line options parsing for Scala
https://github.com/scopt/scopt
command line options parsing for Scala. Contribute to scopt/scopt development by creating an account on GitHub.
- 164Schema safe, type-safe, reactive Scala driver for Cassandra/Datastax Enterprise
https://github.com/outworkers/phantom
Schema safe, type-safe, reactive Scala driver for Cassandra/Datastax Enterprise - outworkers/phantom
- 165A Scala API for Cascading
https://github.com/twitter/scalding
A Scala API for Cascading. Contribute to twitter/scalding development by creating an account on GitHub.
- 166The fastest logging library in the world. Built from scratch in Scala and programmatically configurable.
https://github.com/outr/scribe
The fastest logging library in the world. Built from scratch in Scala and programmatically configurable. - outr/scribe
- 167State of the Art Natural Language Processing
https://github.com/JohnSnowLabs/spark-nlp
State of the Art Natural Language Processing. Contribute to JohnSnowLabs/spark-nlp development by creating an account on GitHub.
- 168Essential Building Blocks for Scala
https://github.com/wvlet/airframe
Essential Building Blocks for Scala. Contribute to wvlet/airframe development by creating an account on GitHub.
- 169ZIO — A type-safe, composable library for async and concurrent programming in Scala
https://github.com/zio/zio
ZIO — A type-safe, composable library for async and concurrent programming in Scala - zio/zio
- 170Lightweight, modular, and extensible library for functional programming.
https://github.com/typelevel/cats
Lightweight, modular, and extensible library for functional programming. - typelevel/cats
- 171Scala validation library
https://github.com/jap-company/fields
Scala validation library. Contribute to jap-company/fields development by creating an account on GitHub.
- 172Cask: a Scala HTTP micro-framework
https://github.com/com-lihaoyi/cask
Cask: a Scala HTTP micro-framework. Contribute to com-lihaoyi/cask development by creating an account on GitHub.
- 173Slick extensions for PostgreSQL
https://github.com/tminglei/slick-pg
Slick extensions for PostgreSQL. Contribute to tminglei/slick-pg development by creating an account on GitHub.
- 174First class syntax support for type classes in Scala
https://github.com/typelevel/simulacrum
First class syntax support for type classes in Scala - typelevel/simulacrum
- 175Persist-Json, a Fast Json Parser Written in Scala
https://github.com/nestorpersist/json
Persist-Json, a Fast Json Parser Written in Scala. Contribute to nestorpersist/json development by creating an account on GitHub.
- 176Refinement types for Scala
https://github.com/fthomas/refined
Refinement types for Scala. Contribute to fthomas/refined development by creating an account on GitHub.
- 177Generic programming for Scala
https://github.com/milessabin/shapeless
Generic programming for Scala. Contribute to milessabin/shapeless development by creating an account on GitHub.
- 178Lift Framework
https://github.com/lift/framework
Lift Framework. Contribute to lift/framework development by creating an account on GitHub.
- 179Fast, testable, Scala services built on TwitterServer and Finagle
https://github.com/twitter/finatra
Fast, testable, Scala services built on TwitterServer and Finagle - twitter/finatra
- 180Build software better, together
https://github.com/wireapp/wire-signals
GitHub is where people build software. More than 100 million people use GitHub to discover, fork, and contribute to over 420 million projects.
- 181The Opinionated RabbitMQ Library for Scala and Akka
https://github.com/SpinGo/op-rabbit
The Opinionated RabbitMQ Library for Scala and Akka - SpinGo/op-rabbit
- 182JSON typeclasses that know the difference between null and absent fields
https://github.com/nrktkt/ninny-json
JSON typeclasses that know the difference between null and absent fields - nrktkt/ninny-json
- 183Scala macros for compile-time generation of safe and ultra-fast JSON codecs + circe booster
https://github.com/plokhotnyuk/jsoniter-scala
Scala macros for compile-time generation of safe and ultra-fast JSON codecs + circe booster - plokhotnyuk/jsoniter-scala
- 184LoMRF is an open-source implementation of Markov Logic Networks
https://github.com/anskarl/LoMRF
LoMRF is an open-source implementation of Markov Logic Networks - anskarl/LoMRF
- 185property based testing library for Scala
https://github.com/scalaprops/scalaprops
property based testing library for Scala. Contribute to scalaprops/scalaprops development by creating an account on GitHub.
- 186Yet another JSON library for Scala
https://github.com/circe/circe
Yet another JSON library for Scala. Contribute to circe/circe development by creating an account on GitHub.
- 187Native Scala mocking framework
https://github.com/paulbutcher/ScalaMock
Native Scala mocking framework. Contribute to paulbutcher/ScalaMock development by creating an account on GitHub.
- 188OAuth 2.0 server-side implementation written in Scala
https://github.com/nulab/scala-oauth2-provider
OAuth 2.0 server-side implementation written in Scala - nulab/scala-oauth2-provider
- 189A small, convenient, dependency-free library for command-line argument parsing in Scala
https://github.com/com-lihaoyi/mainargs
A small, convenient, dependency-free library for command-line argument parsing in Scala - com-lihaoyi/mainargs
- 190Scala + Druid: Scruid. A library that allows you to compose queries in Scala, and parse the result back into typesafe classes.
https://github.com/ing-bank/scruid
Scala + Druid: Scruid. A library that allows you to compose queries in Scala, and parse the result back into typesafe classes. - ing-bank/scruid
- 191akka-persistence-gcp-datastore is a journal and snapshot store plugin for akka-persistence using google cloud firestore in datastore mode.
https://github.com/innFactory/akka-persistence-gcp-datastore
akka-persistence-gcp-datastore is a journal and snapshot store plugin for akka-persistence using google cloud firestore in datastore mode. - GitHub - innFactory/akka-persistence-gcp-datastore: akk...
- 192Mirror of Apache Kafka
https://github.com/apache/kafka
Mirror of Apache Kafka. Contribute to apache/kafka development by creating an account on GitHub.
- 193:leaves: Non-blocking, Reactive MongoDB Driver for Scala
https://github.com/ReactiveMongo/ReactiveMongo
:leaves: Non-blocking, Reactive MongoDB Driver for Scala - ReactiveMongo/ReactiveMongo
- 194Scala GraphQL implementation
https://github.com/sangria-graphql/sangria
Scala GraphQL implementation. Contribute to sangria-graphql/sangria development by creating an account on GitHub.
- 195Functional, stream-based CSV processor for Scala
https://github.com/fingo/spata
Functional, stream-based CSV processor for Scala. Contribute to fingo/spata development by creating an account on GitHub.
- 196ActiveRecord-like ORM library for Scala
https://github.com/aselab/scala-activerecord
ActiveRecord-like ORM library for Scala. Contribute to aselab/scala-activerecord development by creating an account on GitHub.
- 197A Future-free Fs2 native pure FP Redis client
https://github.com/laserdisc-io/laserdisc
A Future-free Fs2 native pure FP Redis client. Contribute to laserdisc-io/laserdisc development by creating an account on GitHub.
- 198Scala framework for building beautiful and maintainable web applications.
https://github.com/UdashFramework/udash-core
Scala framework for building beautiful and maintainable web applications. - UdashFramework/udash-core
- 199Main Portal page for the Jackson project
https://github.com/FasterXML/jackson
Main Portal page for the Jackson project. Contribute to FasterXML/jackson development by creating an account on GitHub.
- 200Library to read, analyze, transform and generate Scala programs
https://github.com/scalameta/scalameta
Library to read, analyze, transform and generate Scala programs - scalameta/scalameta
- 201Compositional, streaming I/O library for Scala
https://github.com/typelevel/fs2
Compositional, streaming I/O library for Scala. Contribute to typelevel/fs2 development by creating an account on GitHub.
- 202The Community Maintained High Velocity Web Framework For Java and Scala.
https://github.com/playframework/playframework
The Community Maintained High Velocity Web Framework For Java and Scala. - playframework/playframework
- 203Scala lightweight, type-safe, asynchronous driver for neo4j
https://github.com/neotypes/neotypes
Scala lightweight, type-safe, asynchronous driver for neo4j - GitHub - neotypes/neotypes: Scala lightweight, type-safe, asynchronous driver for neo4j
- 204Type-safe general-cryptography library - https://jmcardon.github.io/tsec/
https://github.com/jmcardon/tsec
Type-safe general-cryptography library - https://jmcardon.github.io/tsec/ - jmcardon/tsec
- 205JSON library
https://github.com/json4s/json4s
JSON library. Contribute to json4s/json4s development by creating an account on GitHub.
- 206Web & mobile client-side akka-http sessions, with optional JWT support
https://github.com/softwaremill/akka-http-session
Web & mobile client-side akka-http sessions, with optional JWT support - softwaremill/akka-http-session
- 207Lightweight and Nonintrusive Scala Dependency Injection Library
https://github.com/softwaremill/macwire
Lightweight and Nonintrusive Scala Dependency Injection Library - softwaremill/macwire
- 208Rings: efficient JVM library for polynomial rings
https://github.com/PoslavskySV/rings
Rings: efficient JVM library for polynomial rings. Contribute to PoslavskySV/rings development by creating an account on GitHub.
- 209Typesafe, purely functional Computational Intelligence
https://github.com/ciren/cilib
Typesafe, purely functional Computational Intelligence - ciren/cilib
- 210An experimental library for Functional Reactive Programming in Scala
https://github.com/lihaoyi/scala.rx
An experimental library for Functional Reactive Programming in Scala - lihaoyi/scala.rx
- 211New ReactiveCouchbase driver using reactive-streams
https://github.com/ReactiveCouchbase/reactivecouchbase-rs-core
New ReactiveCouchbase driver using reactive-streams - ReactiveCouchbase/reactivecouchbase-rs-core
- 212Simple, safe and intuitive Scala I/O
https://github.com/pathikrit/better-files
Simple, safe and intuitive Scala I/O. Contribute to pathikrit/better-files development by creating an account on GitHub.
- 213Reactive type-safe Scala driver for SQL databases
https://github.com/outworkers/morpheus
Reactive type-safe Scala driver for SQL databases. Contribute to outworkers/morpheus development by creating an account on GitHub.
- 214Lamma schedule generator for Scala is a professional schedule generation library for periodic schedules like fixed income coupon payment, equity deravitive fixing date generation etc.
https://github.com/maxcellent/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. - GitHub - m...
- 215Tiny High Performance HTTP Server for Scala
https://github.com/analogweb/analogweb-scala
Tiny High Performance HTTP Server for Scala . Contribute to analogweb/analogweb-scala development by creating an account on GitHub.
- 216A test framework that runs everything in parallel.
https://github.com/disneystreaming/weaver-test
A test framework that runs everything in parallel. - GitHub - disneystreaming/weaver-test: A test framework that runs everything in parallel.
- 217Clickhouse Scala Client with Reactive Streams support
https://github.com/crobox/clickhouse-scala-client
Clickhouse Scala Client with Reactive Streams support - crobox/clickhouse-scala-client
- 218Memcached client for Scala
https://github.com/monix/shade
Memcached client for Scala. Contribute to monix/shade development by creating an account on GitHub.
- 219A schema-aware Scala library for data transformation
https://github.com/galliaproject/gallia-core
A schema-aware Scala library for data transformation - galliaproject/gallia-core
- 220Efficient CBOR and JSON (de)serialization in Scala
https://github.com/sirthias/borer
Efficient CBOR and JSON (de)serialization in Scala - sirthias/borer
- 221A purely functional Scala client for CouchDB
https://github.com/beloglazov/couchdb-scala
A purely functional Scala client for CouchDB. Contribute to beloglazov/couchdb-scala development by creating an account on GitHub.
- 222The Play JSON library
https://github.com/playframework/play-json
The Play JSON library. Contribute to playframework/play-json development by creating an account on GitHub.
- 223Image comparison by hash codes
https://github.com/poslegm/scala-phash
Image comparison by hash codes. Contribute to poslegm/scala-phash development by creating an account on GitHub.
- 224Avro schema generation and serialization / deserialization for Scala
https://github.com/sksamuel/avro4s
Avro schema generation and serialization / deserialization for Scala - sksamuel/avro4s
- 225Scala combinator library for working with binary data
https://github.com/scodec/scodec
Scala combinator library for working with binary data - scodec/scodec
- 226Minimal, idiomatic, customizable validation Scala library.
https://github.com/yakivy/dupin
Minimal, idiomatic, customizable validation Scala library. - yakivy/dupin
- 227An implementation of an OAuth2 server designed for mocking/testing
https://github.com/zalando-stups/OAuth2-mock-play
An implementation of an OAuth2 server designed for mocking/testing - zalando-stups/OAuth2-mock-play
- 228A type-safe, reflection-free, powerful enumeration implementation for Scala with exhaustive pattern match warnings and helpful integrations.
https://github.com/lloydmeta/enumeratum
A type-safe, reflection-free, powerful enumeration implementation for Scala with exhaustive pattern match warnings and helpful integrations. - lloydmeta/enumeratum
- 229Optics library for Scala
https://github.com/optics-dev/Monocle
Optics library for Scala. Contribute to optics-dev/Monocle development by creating an account on GitHub.
- 230Scala etcd client implementing V3 APIs
https://github.com/mingchuno/etcd4s
Scala etcd client implementing V3 APIs. Contribute to mingchuno/etcd4s development by creating an account on GitHub.
- 231An asynchronous programming facility for Scala
https://github.com/scala/scala-async
An asynchronous programming facility for Scala. Contribute to scala/scala-async development by creating an account on GitHub.
- 232Accord: A sane validation library for Scala
https://github.com/wix/accord
Accord: A sane validation library for Scala. Contribute to wix-incubator/accord development by creating an account on GitHub.
- 233A data access library for Scala + Postgres.
https://github.com/tpolecat/skunk
A data access library for Scala + Postgres. Contribute to typelevel/skunk development by creating an account on GitHub.
- 234tinylog is a lightweight logging framework for Java, Kotlin, Scala, and Android
https://github.com/tinylog-org/tinylog
tinylog is a lightweight logging framework for Java, Kotlin, Scala, and Android - tinylog-org/tinylog
- 235A purely functional library to build distributed and event-driven systems
https://github.com/parapet-io/parapet
A purely functional library to build distributed and event-driven systems - parapet-io/parapet
- 236Non-blocking, Reactive Redis driver for Scala (with Sentinel support)
https://github.com/etaty/rediscala
Non-blocking, Reactive Redis driver for Scala (with Sentinel support) - etaty/rediscala
- 237Wonderful reusable code from Twitter
https://github.com/twitter/util
Wonderful reusable code from Twitter. Contribute to twitter/util development by creating an account on GitHub.
- 238The Scala API for Quantities, Units of Measure and Dimensional Analysis
https://github.com/typelevel/squants
The Scala API for Quantities, Units of Measure and Dimensional Analysis - typelevel/squants
- 239Squid – type-safe metaprogramming and compilation framework for Scala
https://github.com/epfldata/squid
Squid – type-safe metaprogramming and compilation framework for Scala - epfldata/squid
- 240Principled Functional Programming in Scala
https://github.com/scalaz/scalaz
Principled Functional Programming in Scala. Contribute to scalaz/scalaz development by creating an account on GitHub.
- 241sbt plugin that generates Scala case classes for easy, statically typed and implicit access of JSON data e.g. from API responses
https://github.com/battermann/sbt-json
sbt plugin that generates Scala case classes for easy, statically typed and implicit access of JSON data e.g. from API responses - battermann/sbt-json
- 242Accelerate local LLM inference and finetuning (LLaMA, Mistral, ChatGLM, Qwen, Baichuan, Mixtral, Gemma, Phi, MiniCPM, etc.) on Intel CPU and GPU (e.g., local PC with iGPU, discrete GPU such as Arc, Flex and Max); seamlessly integrate with llama.cpp, Ollama, HuggingFace, LangChain, LlamaIndex, GraphRAG, DeepSpeed, vLLM, FastChat, Axolotl, etc.
https://github.com/intel-analytics/BigDL
Accelerate local LLM inference and finetuning (LLaMA, Mistral, ChatGLM, Qwen, Baichuan, Mixtral, Gemma, Phi, MiniCPM, etc.) on Intel CPU and GPU (e.g., local PC with iGPU, discrete GPU such as Arc,...
- 243Mockito for Scala language
https://github.com/mockito/mockito-scala
Mockito for Scala language. Contribute to mockito/mockito-scala development by creating an account on GitHub.
- 244High-performance SLF4J wrapper for Scala.
https://github.com/Log4s/log4s
High-performance SLF4J wrapper for Scala. Contribute to Log4s/log4s development by creating an account on GitHub.
- 245🔍 Elasticsearch Scala Client - Reactive, Non Blocking, Type Safe, HTTP Client
https://github.com/sksamuel/elastic4s
🔍 Elasticsearch Scala Client - Reactive, Non Blocking, Type Safe, HTTP Client - Philippus/elastic4s
- 246aossie / Agora · GitLab
https://gitlab.com/aossie/Agora/
An Electronic Voting Library implemented in Scala
- 247aossie / Scavenger · GitLab
https://gitlab.com/aossie/Scavenger
A theorem prover based on the conflict resolution calculus
- 248SBT plugin for tweaking various IDE settings
https://github.com/JetBrains/sbt-ide-settings
SBT plugin for tweaking various IDE settings. Contribute to JetBrains/sbt-ide-settings development by creating an account on GitHub.
- 249An HTTP Server and Client library for Scala.
https://github.com/criteo/lolhttp
An HTTP Server and Client library for Scala. Contribute to criteo/lolhttp development by creating an account on GitHub.
- 250Scalafmt · Code formatter for Scala
https://scalameta.org/scalafmt/
Code formatter for Scala
- 251sbt plugin that can check Maven and Ivy repositories for dependency updates
https://github.com/rtimush/sbt-updates
sbt plugin that can check Maven and Ivy repositories for dependency updates - rtimush/sbt-updates
- 252Scala command-line wrapper around ffmpeg, ffprobe, ImageMagick, and other tools relating to media.
https://github.com/outr/media4s
Scala command-line wrapper around ffmpeg, ffprobe, ImageMagick, and other tools relating to media. - outr/media4s
- 253friendly little parsers
https://github.com/tpolecat/atto
friendly little parsers. Contribute to tpolecat/atto development by creating an account on GitHub.
- 254simple combinator-based parsing for Scala. formerly part of the Scala standard library, now a separate community-maintained module
https://github.com/scala/scala-parser-combinators
simple combinator-based parsing for Scala. formerly part of the Scala standard library, now a separate community-maintained module - scala/scala-parser-combinators
Related Articlesto learn about angular.
- 1Introduction to Scala: Beginner’s Guide
- 2Understanding Scala’s Type System: Types and Generics
- 3Functional Programming with Scala
- 4Advanced Functional Programming in Scala: Monads, Functors, and More
- 5Building RESTful APIs with Scala and Akka HTTP: A Beginner’s Guide
- 6Play Framework for Scala Web Development: A Step-by-Step Guide
- 7Concurrency in Scala: Mastering Futures and Promises
- 8Optimizing Scala Performance: Tips for High-Performance Scala Applications
- 9Developing a Scala-based Chat Application: From Concept to Deployment
- 10Creating a Scala-based Data Processing Pipeline: Handling Big Data Efficiently
FAQ'sto learn more about Angular JS.
mail [email protected] to add more queries here 🔍.
- 1
can scala do functional programming
- 2
is scala worth learning in 2023
- 3
is scala popular
- 4
is scala a popular language
- 5
why was scala created
- 6
is scala better than python
- 7
can scala use java libraries
- 8
what is the paradigm of the scala programming language
- 9
why use scala programming language
- 10
should i learn scala
- 11
is scala a good language
- 12
is scala a programming language
- 13
where is la scala opera house located
- 14
when was scala created
- 15
how does scala work
- 16
where is scala installed on windows
- 17
why scala is called functional programming language
- 18
does scala use jvm
- 19
where is scala programming language used
- 20
what is scala software
- 21
why learn scala
- 22
why scala over java
- 23
why scala over python
- 24
- 25
where scala is used
- 26
how to learn scala programming
- 27
is scala a popular programming language
- 28
where is la scala located
- 30
who developed scala
- 31
what is scala code
- 32
why scala is not popular
- 33
- 34
- 35
which of the following programming paradigm does scala support
- 36
- 37
can i use scala code in java
- 38
how is scala different from python
- 39
who created scala
- 40
when scala spark
- 41
is scala dead 2023
- 42
who invented scala
- 43
where is la scala located in italy
- 44
- 45
why scala is functional programming language
- 46
is scala open source
- 47
what is scala mostly used for
- 48
is scala written in java
- 49
is scala a dying language
- 50
what is scala programming language used for
- 51
is scala a good programming language
- 52
why scala is better than java
- 53
what is scala programming
- 54
when to use scala
- 55
can i learn scala without java
- 56
does scala compile to java
- 57
why scala is used
- 58
what is functional programming in scala
- 59
should i learn scala reddit
- 60
should i learn java or scala
- 61
how to pronounce scala programming language
- 63
does scala run on jvm
- 64
what is scala programming used for
- 65
who uses scala programming language
- 66
is scala functional programming
More Sitesto check out once you're finished browsing here.
https://www.0x3d.site/
0x3d is designed for aggregating information.
https://nodejs.0x3d.site/
NodeJS Online Directory
https://cross-platform.0x3d.site/
Cross Platform Online Directory
https://open-source.0x3d.site/
Open Source Online Directory
https://analytics.0x3d.site/
Analytics Online Directory
https://javascript.0x3d.site/
JavaScript Online Directory
https://golang.0x3d.site/
GoLang Online Directory
https://python.0x3d.site/
Python Online Directory
https://swift.0x3d.site/
Swift Online Directory
https://rust.0x3d.site/
Rust Online Directory
https://scala.0x3d.site/
Scala Online Directory
https://ruby.0x3d.site/
Ruby Online Directory
https://clojure.0x3d.site/
Clojure Online Directory
https://elixir.0x3d.site/
Elixir Online Directory
https://elm.0x3d.site/
Elm Online Directory
https://lua.0x3d.site/
Lua Online Directory
https://c-programming.0x3d.site/
C Programming Online Directory
https://cpp-programming.0x3d.site/
C++ Programming Online Directory
https://r-programming.0x3d.site/
R Programming Online Directory
https://perl.0x3d.site/
Perl Online Directory
https://java.0x3d.site/
Java Online Directory
https://kotlin.0x3d.site/
Kotlin Online Directory
https://php.0x3d.site/
PHP Online Directory
https://react.0x3d.site/
React JS Online Directory
https://angular.0x3d.site/
Angular JS Online Directory