All Versions
31
Latest Version
Avg Release Cycle
54 days
Latest Release
114 days ago
Changelog History
Page 1
Changelog History
Page 1

v5.2.0
February 08, 2020🔄 Changed
HList#cons
static factory method autopromotes to specializedHList
if there is oneEitherT
gains aMonadError
instance
➕ Added
 🔀
MergeHMaps
, aMonoid
that mergesHMap
s by merging the values via keyspecifiedSemigroup
s Id#id
overload that accepts an argument and returns itMaybeT#or
, choose the firstMaybeT
that represents an effect aroundjust
a valueMaybeT#filter
, filter aMaybe
inside an effectStateMatcher, StateTMatcher, WriterTMatcher
ReaderT#and
, category composition betweenReaderT
instances:(a > m b) > (b > m c) > (a > m c)
IterateT
,ListT
done rightComparison
, a typesafe sum ofLT
,EQ
, andGT
orderingsCompare
, a function taking aComparator
and returning aComparison
 ✅
Min/Max/...With
variants for inequality testing with aComparator

v5.1.0
October 13, 2019🔄 Changed
 👍 All monad transformers that can support composable parallelism do support it
➕ Added
Writer
, the writer monadEndoK
, a monoid formed under endomorphism for any monadAutoBracket
, a specialized form ofBracket
forAutoCloseable
that closes the resource during cleanup
🛠 Fixed
SafeT#zip
is now stacksafe regardless of the underlying monad'szip
implementation
🗄 Deprecated
Force
, in favor if traversing into anIO
and explicitly running it

v5.0.0
September 18, 2019🔄 Changed
 Breaking Change:
MonadT
is now witnessed by a parameter for better subtyping, and no longer requires a commonrun
interface; eachrun
method is nowrunXXXT()
, whereXXX
is the name of the transformer in question  Breaking Change:
Applicative#zip
and derivatives evaluate from left to right now across the board.  Breaking Change:
testsupport.EquatableM
replaced withEquivalence
Alter
now merely requires anFn1
instead of an explicitEffect
IO
now internally trampolines all forms of composition, includinglazyZip
; sequencing very large iterables ofIO
will work, if you have the heap, and retain parallelization inflection points
➕ Added
 0️⃣
MonadRec
, monads that support a stacksafetrampolineM
method with defaults for all exported monads  0️⃣
MonadError
, monads that can be thrown to and caught from, with defaults forIO
,Either
,Maybe
, andTry
MonadBase
, an interface representing lifting infrastructure forMonad
sMonadReader
andMonadWriter
, general interfaces for reading from an environment and accumulating resultsSafeT
, a stacksafe monad transformer for anyMonadRec
ReaderT
, the transformer for the reader monadWriterT
, a monad transformer for an accumulation and a valueStateT
, theState
monad transformerLift
, an existentiallyquantified lifting function for someMonadBase
typeIO#interruptible
, for wrapping anIO
in a thread interruption check 🔒
IO#monitorSync
, for wrapping anIO
in asynchronized
block on a given lock object  📌
IO#pin
, for pinning anIO
to anExecutor
without yet executing it IO#fuse
, for fusing the fork opportunities of a givenIO
into a single linearizedIO
IO#memoize
, for memoizing anIO
by caching its first successful resultUntil
, for repeatedly executing anIO
until its result matches a predicate 0️⃣
Optic#andThen
,Optic#compose
, and other defaults added Prism#andThen
,Prism#compose
begets anotherPrism
Prism#fromPartial
public interfacesTuple28#fromIterable
, for populating aTupleN
with the firstN
elements of anIterable
Fn2#curry
, for converting anFn1<Tuple2<A,B>,C>
to anFn2<A,B,C>
 ✅
EquivalenceTrait
, a traitorTrait
to make it easier to test properties of typeclasses with a separate equivalence relation
🗄 Deprecated
Peek
,Peek2
,Maybe#peek
, andEither#peek
in favor of explicitly matching intoIO
and running itForce
, in favor if traversing into anIO
and explicitly running itIO#exceptionally
in favor ofIO#catchError
(fromMonadError
)
 Breaking Change:

v4.0.0
May 21, 2019🔄 Changed
 Breaking Change:
IO
is now sealed and moved to its own package. Most previous constructions using the static factory methods should continue to work (by simply targetingSupplier
now instead of an anonymousIO
), but some might need to be reworked, and subtyping is obviously no longer supported.  Breaking Change: Breaking all dependency on
java.util.function
types across the board. AllFn*
types target methods now support throwingThrowable
;apply
is now defaulted and will simply bypass javac to throw checked exceptions as if they were unchecked. AllChecked
variants have been eliminated as a consequence, as they are no longer necessary. Also, straggler functions likePartial2/3
that only existed to aid in partial application of noncurried functions are now superfluous, and have also been eliminated.  Breaking Change:
FoldRight
now requiresLazy
as part of its interface to support shortcircuiting operations  Breaking Change: Eliminated all raw types and java11 warnings. This required using capture in unification parameters for Functor and friends, so nearly every functor's typesignature changed.
 Breaking Change:
Strong
is now calledCartesian
to better reflect the type of strength  Breaking Change: new Optic type hierarchy more faithfully encodes profunctor constraints on optics, new
Optic
type is now the supertype ofLens
andIso
, andlens
package has been moved tooptics
 Breaking Change:
Try
andEither
no longer preserveThrowable
type since it was inherently not typesafe anyway; Try is therefore no longer aBifunctor
, andorThrow
can be used to declare checked exceptions that could be caught by corresponding catch blocks IO
is now stacksafe, regardless of whether the composition nests linearly or recursively
➕ Added
 👍
Lazy
, a monad supporting stacksafe lazy evaluation LazyRec
, a function for writing stacksafe recursive algorithms embedded inLazy
Applicative#lazyZip
, for zipping two applicatives in a way that might not require evaluation of one applicativeMonadT
, a general interface representing monad transformersMaybeT
, a monad transformer forMaybe
EitherT
, a monad transformer forEither
IdentityT
, a monad transformer forIdentity
LazyT
, a monad transformer forLazy
Endo
, a monoid formed byFn1
under compositionState
, the stateMonad
 👍
Downcast
, a function supporting unchecked downcasting Cocartesian
, profunctorial strength in cocartesian coproduct termsPrism
, anOptic
that is nearly anIso
but can fail in one direction 👍
Market
,Tagged
, profunctors supporting optics Re
for viewing anOptic
in one direction reliablyPre
for viewing at most one value from anOptic
in one directionSideEffect
, for representing sideeffects runnable byIO
IO#safe
, mapping anIO<A>
to anIO<Either<Throwable, A>>
that will never throwIO#ensuring
, likefinally
semantics forIO
sIO#throwing
, for producing anIO<A>
that will throw a givenThrowable
when executedBracket
, for bracketing anIO
operation with a mapping operation and a cleanup operation
 Breaking Change:

v3.3.0
February 20, 2019➕ Added
 🔀
MergeMaps
, aMonoid
onMap
formed byMap#merge
CheckedEffect
is now aCheckedFn1
CheckedSupplier
is now aCheckedFn1
CheckedFn1
now overrides all possible methods with covariant return typeMapLens#asCopy
has overload taking copy functionMapLens#valueAt
has overload taking copy functionSortWith
for sorting anIterable
given aComparator
over its elementsIO#externallyManaged
, for supplying anIO
with externallymanaged futures ✅ test jar is now published
Monad#join
static alias forflatMap(id())
Effect#effect
static factory method takingFn1
IO#unsafePerformAsyncIO
overloads for runningIO
s asynchronouslyIO
s automatically encode parallelism in compositionIO#exceptionally
for recovering from failure duringIO
operationOptic
, a generic supertype for all profunctor optics
🛠 Fixed
 issue where certain ways to compose
Effect
s unintentionally nullified the effect
✂ Removed
 🚀
AddAll
semigroup, deprecated in previous release  🚀 Dyadic
Either#flatMap()
, deprecated in previous release
 🔀

v3.2.0
December 08, 2018🔄 Changed
 Breaking Change:
Difference
andIntersection
no longer instances ofSemigroup
and moved tofunctions.builtin.fn2
package  Breaking Change:
Absent
moved tosemigroup.builtin
package  Breaking Change:
Effect#accept()
is now the required method to implement in the functional interface  Breaking Change:
Fn0#apply()
is now the required method to implement in the functional interface  Breaking Change:
GTBy
,GT
,LTBy
,LT
,GTEBy
,GTE
,LTEBy
, andLTE
take the righthand side first for more intuitive partial application  Breaking Change:
Effect
now returns anIO
RightAny
overload returnsMonoid
 monoids now all fold with respect to
foldMap
 monoid folding now implicitly starts with the identity, regardless of iterable population
Concat
monoid can now fold infinite iterables 👍 all
Function<? super XXX, Boolean>
are nowFunction<? super XXX, ? extends Boolean>
for better compatibility Either#diverge
returns aChoice3
Maybe
is now aCoProduct2
ofUnit
andA
Fn0
now additionally implementsCallable
CheckedRunnable
is anIO<Unit>
➕ Added
Predicate#predicate
static factory methodProduct28
left/right rotation methodsTuple28
specializations of left/right product rotationCheckedEffect
, anEffect
variant that can throw checked exceptionsCheckedFn1#checked
, convenience static factory method to aid inference 🔊
LiftA38
, higherarity analogs toLiftA2
Alter
, for applying anEffect
to an input and returning it, presumably alteredClamp
, for clamping a value between two boundsBetween
, for determining if a value is in a closed intervalStrong
, profunctor strengthIO
monadRunAll
semigroup and monoid instance forIO<A>
🗄 Deprecated
AddAll
semigroup, in favor of the monoid that no longer mutates any argument Dyadic
Either#flatMap()
, in favor ofEither#match
 Breaking Change:

v3.1.0
July 17, 2018➕ Added
Fn38
static factory overloads to aid in coercing lambdas ➕ Adding composition guarantees to
LensLike
CmpEqBy
,CmpEq
,GTBy
,GT
,LTBy
,LT
,GTEBy
,GTE
,LTEBy
, andLTE
inequality checksMinBy
,MaxBy
,Min
, andMax
semigroupsProduct28
interfaces, representing general product typesUnion
, a monoid that behaves like a lazy set union onIterable
sDifference
, a semigroup that behaves like a partially lazy set difference onIterable
sLambdaMap
, extension point forj.u.Map
, similar toLambdaIterable
Sequence#sequence
overloads forj.u.Map
that traverse via intermediateLambdaMap
instancesIntersection
, a semigroup that behaves like a lazy set intersection onIterable
sFn0
, a function fromUnit
to some valueFn1#thunk
, producing anFn0
Absent
, a monoid overMaybe
that is absence biasedRateLimit
, a function that iterates elements from anIterable
according to some rate limitTry#withResources
,Try
's expression analog to Java 7's trywithresources statementOccurrences
, for counting the occurrences of the members of anIterable
Effect
, anFn0
returningUNIT
Noop
, a noopEffect
Fn1#widen
, add an ignored argument to the beginning of any function to raise its arity by one
🔄 Changed
Tuple28
now implementProduct28
Into
now acceptsMap.Entry
Into38
now accept a product of the same cardinality, instead of requiring a tupleCoProduct28#project
now return generalized productsChoice28#project
return tuplesliftA2
receives more parameters to aid inference 👍
Compose#getCompose
now supports inference
✂ Removed
 🚀
MapLens#mappingValues
, deprecated in a prior release  🚀
CollectionLens#asSet
, deprecated in a prior release  🚀
CollectionLens#asStream
, deprecated in a prior release

v3.0.3
May 27, 2018➕ Added
Lens#toIso
, for converting a lens to an isoHMap#hMap
overloads up to 8 bindings deepSchema
, schemas for extracting multiple values fromHMap
s by aggregatingTypeSafeKey
s
🛠 Fixed
 Deforested iterables execute in intended nesting order, where essential

v3.0.2
May 21, 2018➕ Added
IterableLens#mapping
, anIso
that maps values
🔄 Changed
 0️⃣
TypeSafeKey.Simple
now has a default#apply
implementation
🛠 Fixed
 mapped
TypeSafeKey
instances can be used for initial put in anHMap
, and the base key can be used to retrieve them  🔀 Merged pull request fixing issue storing values at mapped
TypeSafeKey
insingletonHMap

v3.0.1
May 13, 2018🔄 Changed
ToMap
accepts anIterable
covariant inMap.Entry
RecursiveResult#invert
is also aRecursiveResult
First
/And
/Or
monoids all utilize shortcircuitingMonoid#foldLeft/foldRight
delegate toMonoid#reduceLeft/reduceRight
, respectively
➕ Added
Upcast
for safely casting up a type hierarchySetLens
, lenses operating onSet
sToArray
, for convertingIterable<A>
toA[]