All Versions
33
Latest Version
Avg Release Cycle
76 days
Latest Release
1728 days ago

Changelog History
Page 1

  • v5.4.0 Changes

    September 17, 2021

    🔄 Changed

    • Absent folds short-circuit on the first nothing()
    • 👍 EitherMatcher#isLeftThat/isRightThat support contravariant bounds on their delegates

    ➕ Added

    • IterateT#runStep, a method used to run a single step of an IterateT without the contractual guarantee of emitting a value or reaching the end
    • These#fromMaybes :: Maybe a -> Maybe b -> Maybe (These a b)
    • EitherMatcher#isLeftOf/isRightOf for asserting equality

    🛠 Fixed

    • WriterT now keeps an immediate reference to the embedded monad's pure

  • v5.3.0 Changes

    December 07, 2020

    🔄 Changed

    • IterateT#unfold now only computes a single Pure for the given input
    • ReaderT#fmap and StateT#fmap avoid unnecessary calls to pure
    • MaybeT implements MonadError

    ➕ Added

    • $, function application represented as a higher-order Fn2
    • Fn1#withSelf, a static method for constructing a self-referencing Fn1
    • HNil/SingletonHList/TupleX#snoc, a method to add a new last element (append to a tuple)
    • Tuple2-8#init, for populating a TupleN with all but the last element

    🛠 Fixed

    • IterateT#trampolineM now yields and stages all recursive result values, rather than prematurely terminating on the first termination result
    • IterateT#flatMap is now stack-safe regardless of how many consecutive empty IterateTs are returned and regardless of whether the monad is strict or lazy or internally trampolined

  • v5.2.0 Changes

    February 08, 2020

    🔄 Changed

    • HList#cons static factory method auto-promotes to specialized HList if there is one
    • EitherT gains a MonadError instance

    ➕ Added

    • 🔀 MergeHMaps, a Monoid that merges HMaps by merging the values via key-specified Semigroups
    • Id#id overload that accepts an argument and returns it
    • MaybeT#or, choose the first MaybeT that represents an effect around just a value
    • MaybeT#filter, filter a Maybe inside an effect
    • StateMatcher, StateTMatcher, WriterTMatcher
    • ReaderT#and, category composition between ReaderT instances: (a -> m b) -> (b -> m c) -> (a -> m c)
    • IterateT, ListT done right
    • Comparison, a type-safe sum of LT, EQ, and GT orderings
    • Compare, a function taking a Comparator and returning a Comparison
    • ✅ Min/Max/...With variants for inequality testing with a Comparator

  • v5.1.0 Changes

    October 13, 2019

    🔄 Changed

    • 👍 All monad transformers that can support composable parallelism do support it

    ➕ Added

    • Writer, the writer monad
    • EndoK, a monoid formed under endomorphism for any monad
    • AutoBracket, a specialized form of Bracket for AutoCloseable that closes the resource during cleanup

    🛠 Fixed

    • SafeT#zip is now stack-safe regardless of the underlying monad's zip implementation

    🗄 Deprecated

    • Force, in favor if traversing into an IO and explicitly running it

  • v5.0.0 Changes

    September 18, 2019

    🔄 Changed

    • Breaking Change: MonadT is now witnessed by a parameter for better subtyping, and no longer requires a common run interface; each run method is now runXXXT(), where XXX 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 with Equivalence
    • Alter now merely requires an Fn1 instead of an explicit Effect
    • IO now internally trampolines all forms of composition, including lazyZip; sequencing very large iterables of IO will work, if you have the heap, and retain parallelization inflection points

    ➕ Added

    • 0️⃣ MonadRec, monads that support a stack-safe trampolineM method with defaults for all exported monads
    • 0️⃣ MonadError, monads that can be thrown to and caught from, with defaults for IO, Either, Maybe, and Try
    • MonadBase, an interface representing lifting infrastructure for Monads
    • MonadReader and MonadWriter, general interfaces for reading from an environment and accumulating results
    • SafeT, a stack-safe monad transformer for any MonadRec
    • ReaderT, the transformer for the reader monad
    • WriterT, a monad transformer for an accumulation and a value
    • StateT, the State monad transformer
    • Lift, an existentially-quantified lifting function for some MonadBase type
    • IO#interruptible, for wrapping an IO in a thread interruption check
    • 🔒 IO#monitorSync, for wrapping an IO in a synchronized block on a given lock object
    • 📌 IO#pin, for pinning an IO to an Executor without yet executing it
    • IO#fuse, for fusing the fork opportunities of a given IO into a single linearized IO
    • IO#memoize, for memoizing an IO by caching its first successful result
    • Until, for repeatedly executing an IO until its result matches a predicate
    • 0️⃣ Optic#andThen, Optic#compose, and other defaults added
    • Prism#andThen, Prism#compose begets another Prism
    • Prism#fromPartial public interfaces
    • Tuple2-8#fromIterable, for populating a TupleN with the first N elements of an Iterable
    • Fn2#curry, for converting an Fn1<Tuple2<A,B>,C> to an Fn2<A,B,C>
    • ✅ EquivalenceTrait, a traitor Trait to make it easier to test properties of type-classes with a separate equivalence relation

    🗄 Deprecated

    • Peek, Peek2, Maybe#peek, and Either#peek in favor of explicitly matching into IO and running it
    • Force, in favor if traversing into an IO and explicitly running it
    • IO#exceptionally in favor of IO#catchError (from MonadError)

  • v4.0.0 Changes

    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 targeting Supplier now instead of an anonymous IO), 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. All Fn* types target methods now support throwing Throwable; apply is now defaulted and will simply bypass javac to throw checked exceptions as if they were unchecked. All Checked variants have been eliminated as a consequence, as they are no longer necessary. Also, straggler functions like Partial2/3 that only existed to aid in partial application of non-curried functions are now superfluous, and have also been eliminated.
    • Breaking Change: FoldRight now requires Lazy as part of its interface to support short-circuiting 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 type-signature changed.
    • Breaking Change: Strong is now called Cartesian 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 of Lens and Iso, and lens package has been moved to optics
    • Breaking Change: Try and Either no longer preserve Throwable type since it was inherently not type-safe anyway; Try is therefore no longer a Bifunctor, and orThrow can be used to declare checked exceptions that could be caught by corresponding catch blocks
    • IO is now stack-safe, regardless of whether the composition nests linearly or recursively

    ➕ Added

    • 👍 Lazy, a monad supporting stack-safe lazy evaluation
    • LazyRec, a function for writing stack-safe recursive algorithms embedded in Lazy
    • Applicative#lazyZip, for zipping two applicatives in a way that might not require evaluation of one applicative
    • MonadT, a general interface representing monad transformers
    • MaybeT, a monad transformer for Maybe
    • EitherT, a monad transformer for Either
    • IdentityT, a monad transformer for Identity
    • LazyT, a monad transformer for Lazy
    • Endo, a monoid formed by Fn1 under composition
    • State, the state Monad
    • 👍 Downcast, a function supporting unchecked down-casting
    • Cocartesian, profunctorial strength in cocartesian coproduct terms
    • Prism, an Optic that is nearly an Iso but can fail in one direction
    • 👍 Market, Tagged, profunctors supporting optics
    • Re for viewing an Optic in one direction reliably
    • Pre for viewing at most one value from an Optic in one direction
    • SideEffect, for representing side-effects runnable by IO
    • IO#safe, mapping an IO<A> to an IO<Either<Throwable, A>> that will never throw
    • IO#ensuring, like finally semantics for IOs
    • IO#throwing, for producing an IO<A> that will throw a given Throwable when executed
    • Bracket, for bracketing an IO operation with a mapping operation and a cleanup operation

  • v3.3.0 Changes

    February 20, 2019

    ➕ Added

    • 🔀 MergeMaps, a Monoid on Map formed by Map#merge
    • CheckedEffect is now a CheckedFn1
    • CheckedSupplier is now a CheckedFn1
    • CheckedFn1 now overrides all possible methods with covariant return type
    • MapLens#asCopy has overload taking copy function
    • MapLens#valueAt has overload taking copy function
    • SortWith for sorting an Iterable given a Comparator over its elements
    • IO#externallyManaged, for supplying an IO with externally-managed futures
    • ✅ test jar is now published
    • Monad#join static alias for flatMap(id())
    • Effect#effect static factory method taking Fn1
    • IO#unsafePerformAsyncIO overloads for running IOs asynchronously
    • IOs automatically encode parallelism in composition
    • IO#exceptionally for recovering from failure during IO operation
    • Optic, a generic supertype for all profunctor optics

    🛠 Fixed

    • issue where certain ways to compose Effects unintentionally nullified the effect

    ✂ Removed

    • 🚀 AddAll semigroup, deprecated in previous release
    • 🚀 Dyadic Either#flatMap(), deprecated in previous release

  • v3.2.0 Changes

    December 08, 2018

    🔄 Changed

    • Breaking Change: Difference and Intersection no longer instances of Semigroup and moved to functions.builtin.fn2 package
    • Breaking Change: Absent moved to semigroup.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, and LTE take the right-hand side first for more intuitive partial application
    • Breaking Change: Effect now returns an IO
    • RightAny overload returns Monoid
    • 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 now Function<? super XXX, ? extends Boolean> for better compatibility
    • Either#diverge returns a Choice3
    • Maybe is now a CoProduct2 of Unit and A
    • Fn0 now additionally implements Callable
    • CheckedRunnable is an IO<Unit>

    ➕ Added

    • Predicate#predicate static factory method
    • Product2-8 left/right rotation methods
    • Tuple2-8 specializations of left/right product rotation
    • CheckedEffect, an Effect variant that can throw checked exceptions
    • CheckedFn1#checked, convenience static factory method to aid inference
    • 🔊 LiftA3-8, higher-arity analogs to LiftA2
    • Alter, for applying an Effect to an input and returning it, presumably altered
    • Clamp, for clamping a value between two bounds
    • Between, for determining if a value is in a closed interval
    • Strong, profunctor strength
    • IO monad
    • RunAll semigroup and monoid instance for IO<A>

    🗄 Deprecated

    • AddAll semigroup, in favor of the monoid that no longer mutates any argument
    • Dyadic Either#flatMap(), in favor of Either#match

  • v3.1.0 Changes

    July 17, 2018

    ➕ Added

    • Fn3-8 static factory overloads to aid in coercing lambdas
    • ➕ Adding composition guarantees to LensLike
    • CmpEqBy, CmpEq, GTBy, GT, LTBy, LT, GTEBy, GTE, LTEBy, and LTE inequality checks
    • MinBy, MaxBy, Min, and Max semigroups
    • Product2-8 interfaces, representing general product types
    • Union, a monoid that behaves like a lazy set union on Iterables
    • Difference, a semigroup that behaves like a partially lazy set difference on Iterables
    • LambdaMap, extension point for j.u.Map, similar to LambdaIterable
    • Sequence#sequence overloads for j.u.Map that traverse via intermediate LambdaMap instances
    • Intersection, a semigroup that behaves like a lazy set intersection on Iterables
    • Fn0, a function from Unit to some value
    • Fn1#thunk, producing an Fn0
    • Absent, a monoid over Maybe that is absence biased
    • RateLimit, a function that iterates elements from an Iterable according to some rate limit
    • Try#withResources, Try's expression analog to Java 7's try-with-resources statement
    • Occurrences, for counting the occurrences of the members of an Iterable
    • Effect, an Fn0 returning UNIT
    • Noop, a no-op Effect
    • Fn1#widen, add an ignored argument to the beginning of any function to raise its arity by one

    🔄 Changed

    • Tuple2-8 now implement Product2-8
    • Into now accepts Map.Entry
    • Into3-8 now accept a product of the same cardinality, instead of requiring a tuple
    • CoProduct2-8#project now return generalized products
    • Choice2-8#project return tuples
    • liftA2 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 Changes

    May 27, 2018

    ➕ Added

    • Lens#toIso, for converting a lens to an iso
    • HMap#hMap overloads up to 8 bindings deep
    • Schema, schemas for extracting multiple values from HMaps by aggregating TypeSafeKeys

    🛠 Fixed

    • Deforested iterables execute in intended nesting order, where essential