All notable changes to this project will be documented in this file.

The format is based on Keep a Changelog.

• 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
• Tuple2-8#init, for populating a TupleN with all but the last element

• $, 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)

• 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

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

• 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

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

• 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

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

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

• 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

• MonadRec, monads that support a stack-safe trampolineM method with defaults for all exported monads
• 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
• 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

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

• 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

• 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

• 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

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

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

• 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>

• 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>

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

• 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

• 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

• MapLens#mappingValues, deprecated in a prior release
• CollectionLens#asSet, deprecated in a prior release
• CollectionLens#asStream, deprecated in a prior release

• 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

• Deforested iterables execute in intended nesting order, where essential

• IterableLens#mapping, an Iso that maps values

• TypeSafeKey.Simple now has a default #apply implementation

• mapped TypeSafeKey instances can be used for initial put in an HMap, and the base key can be used to retrieve them
• Merged pull request fixing issue storing values at mapped TypeSafeKey in singletonHMap

• ToMap accepts an Iterable covariant in Map.Entry
• RecursiveResult#invert is also a RecursiveResult
• First/And/Or monoids all utilize short-circuiting
• Monoid#foldLeft/foldRight delegate to Monoid#reduceLeft/reduceRight, respectively

• Upcast for safely casting up a type hierarchy
• SetLens, lenses operating on Sets
• ToArray, for converting Iterable<A> to A[]

• Breaking Change: Sequence now has two more type parameters to aid in inference
• Breaking Change: Traversable#traverse now has three more type parameters to aid in inference
• Breaking Change: Monad#zip now forces m a -> b before m a in default Applicative#zip implementation; this is only breaking for types that are sensitive to computation order (the resulting values are the same)
• Breaking Change: TypeSafeKey is now dually parametric (single parameter analog is preserved in TypeSafeKey.Simple)
• Bifunctor is now a BoundedBifunctor where both parameter upper bounds are Object
• Peek2 now accepts the more general BoundedBifunctor
• Identity, Compose, and Const functors all have better toString implementations
• Into3-8 now supports functions with parameter variance
• HListLens#tail is now covariant in Tail parameter
• More functions now automatically deforest nested calls (concat cons, cycle, distinct, drop, dropwhile, filter, map, reverse, snoc, take, takewhile, tail)
• Flatten calls Iterator#hasNext less aggressively, allowing for better laziness
• Lens subtypes LensLike
• View/Set/Over now only require LensLike
• HMap#keys now returns a Set
• HMap#values now returns a Collection
• Unfoldr is now lazier, deferring all computations until hasNext/next calls
• Present is now a singleton

• BoundedBifunctor, a Bifunctor super type that offers upper bounds for both parameters
• Try, a Monad representing an expression-like analog of try/catch/finally
• CheckedRunnable, the Runnable counterpart to CheckedSupplier that can throw checked exceptions
• Unit, the lambda analog to Void, except actually inhabited by a singleton instance
• Kleisli, the abstract representation of a Kleisli arrow (Monad#flatMap) as an Fn1
• These, a CoProduct3 of A, B, or Tuple2<A,B>
• Span, for splitting an Iterable into contiguous elements matching a predicate
• MagnetizeBy and Magnetize, for grouping elements by pairwise predicate tests
• Both, for dually applying two functions and producing a Tuple2 of their results
• Lens#both, for dually focusing with two lenses at once
• IfThenElse, an expression form for if statements
• CheckedRunnable and CheckedSupplier conversion and convenience methods
• LensLike, common capabilities that make a type usable as if it were a Lens
• Iso, isomorphisms between two types (invertible functions that are also lenses)
• Exchange, a Profunctor that can extract the morphisms from an Iso
• HMapLens, lenses focusing on HMap
• MapLens#mappingValues(Iso), a lawful lens that maps the values of a j.u.Map
• Under, the inverse of Over for Iso
• TypeSafeKey is an Iso and supports mapping
• TypeSafeKey.Simple, the single parameter version of TypeSafeKey
• Either#trying overloads that accept CheckedRunnable

• MapLens#mappingValues(Function) is now deprecated in favor of the overload that takes an Iso

• Breaking Change: Moved Trampoline and RecursiveResult to better package

• Breaking Change: CollectionLens#asSet is now lawful and preserves new incoming values in the update set
• Breaking Change: IterableLens#head is now a Lens.Simple<Iterable<A>, Maybe<A>> and is lawful
• Breaking Change: ListLens#elementAt is now a Lens.Simple<List<X>, Maybe<X>> supporting defensive copies
• Breaking Change: MapLens#valueAt is now a Lens.Simple<Map<K,V>, Maybe<V>> supporting defensive copies
• MapLens#keys now uses defensive copies and does not alter the focused on map
• MapLens#values now uses defensive copies and does not alter the focused on map
• MapLens#inverted now uses defensive copies and does not alter the focused on map
• HListLens#head is now covariant in the tail of both S and T
• Predicate#contraMap is now covariant in its return type
• BiPredicate#contraMap and BiPredicate#diMapL are now both covariant in their return types

• Fn3#fn3 and Fn4#fn4 static factory methods
• Fn5 through Fn8
• Tuple5#into
• Tuple6 through Tuple8
• CoProduct6 through CoProduct8 and Choice6 through Choice8
• CoProduct5#diverge and Choice5#diverge
• Into3 through Into8, for applying a Tuple* to an Fn*
• Times, for successively accumulating a result by iterating a function over a value some number of times
• Slide, for "sliding" a window of some number of elements across an Iterable
• Either#filter overload supporting a function from R to L in the failing predicate case
• CollectionLens#asSet(Function), a proper analog of CollectionLens#asSet() that uses defensive copies
• CollectionLens#asStream(Function), a proper analog of CollectionLens#asStream() that uses defensive copies
• Explicitly calling attention to all unlawful lenses in their documentation
• Peek and Peek2, for "peeking" at the value contained inside any given Functor or Bifunctor with given side-effects
• Trampoline and RecursiveResult for modeling primitive tail-recursive functions that can be trampolined

• Either#toOptional, deprecated in previous release
• Either#fromOptional, deprecated in previous release
• sequence overloads supporting Optional, deprecated in previous release
• OptionalLens, deprecated in previous release
• TraversableIterable, deprecated in previous release
• Traversables, deprecated in previous release

• CollectionLens#asSet() in favor of CollectionLens#asSet(Function)
• CollectionLens#asStream() in favor of CollectionLens#asStream(Function)

• Breaking Change: java.util.Optional replaced with Maybe across the board
• Profunctor#diMap/L/R parameters allow variance
• Either#toOptional no longer allows null values in the right side, and is now in sync with CoProduct#projectB
• Unfoldr allows variance on input

• CoProductN#embed no longer eagerly invokes functions
• PrependAll now only creates O(1) Iterables instead of O(3n + 1)

• Monad arrives. The following Applicatives are now also Monad:
  • Lens
  • Const
  • Tuple*
  • Choice*
  • Identity
  • Either
  • Fn*
  • LambdaIterable
  • Maybe
  • SingletonHList
• Force, for forcing iteration of an Iterable to perform any side-effects
• Snoc, for lazily appending an element to the end of an Iterable
• Coalesce, for folding an Iterable<Either<L, R>> into an Either<Iterable<L>, Iterable<R>>
• And, Or, and Xor all gain BiPredicate<Boolean, Boolean> properties
• LambdaIterable, an adapter Iterable that support lambda types
• Maybe, lambda's analog of java.util.Optional conforming to all the lambda types
• Contravariant, an interface representing functors that map contravariantly over their parameters
• Profunctor extends Contravariant
• Tails, for iterating all the tail element subsequences of an Iterable
• Inits, for iterating all the initial element subsequences of an Iterable
• Init, for iterating all but the last element of an Iterable
• CatMaybes, for unwrapping the present values in an Iterable<Maybe<A>> to produce an Iterable<A>

• Fn1#then(Function<? super B, ? extends C>), deprecated in previous release
• Fn1#adapt(Function<A, B> function), deprecated in previous release
• Fn2#adapt(BiFunction<A, B, C> biFunction), deprecated in previous release

• Traversables and all methods therein, in favor of either LambdaIterable or Maybe
• TraversableOptional in favor of Maybe
• TraversableIterable in favor of LambdaIterable
• Sequence overloads supporting Optional in favor of converting Optional to Maybe and then sequencing
• Either#toOptional and Either#fromOptional in favor of its Maybe counterparts

• Loosening variance on Fn2#fn2 and Fn1#fn1

• ConcatenatingIterator bug where deeply nested xs skip elements

• Fn1#then in favor of Fn1#andThen (redundant)
• Fn1#adapt in favor of Fn1#fn1 (rename)
• Fn2#adapt in favor of Fn2#fn2 (rename)

• Fn1#andThen overload to support composition with Bifunction
• Fn1#compose overload to support composition with Bifunction and Fn2
• LiftA2 to lift and apply a Bifunction to two Applicatives
• Flatten to lazily flatten nested Iterable<Iterable<A>>s to Iterable<A>
• Replicate, short-hand composition of take and repeat
• Distinct to produce an Iterable of distinct values in another Iterable
• Sort and SortBy for eagerly, monolithically sorting Iterables and producing Lists
• IterableLens, general lenses over Iterable
• Xor, a monoid representing logical exclusive-or

• Removing need for various suppressed unchecked warnings in ChoiceN types
• HList abstract super type loses both unnecessary parameters

• ClassCastException BiPredicate.flip

• Uncons, for destructuring an Iterable into its head and tail
• Compose semigroup and monoid formed over CompletableFuture
• Monoid and Semigroup both preserve type specificity through flip calls

• Loosening visibility on Traversables methods to public

• Functor, Bifunctor, and Profunctor (as well as all instances) get a unification parameter
• Identity supports value equality
• Const supports value equality
• partition now only requires iterables of CoProudct2
• CoProductNs receive a unification parameter, which trickles down to Either and Choices
• Concat now represents a monoid for Iterable; previous Concat semigroup and monoid renamed to more appropriate AddAll
• Lens is now an instance of Profunctor

• Either#invert is pulled up into CoProduct2 and additionally specialized for Choice2
• CoProductN#embed
• not, used for negating predicate functions
• empty, used to test if an Iterable is empty
• groupBy, for folding an Iterable into a Map given a key function
• Applicative arrives; all functors gain applicative properties
• Traversable arrives; SingletonHList, Tuple*, Choice*, Either, Identity, and Const gain traversable properties
• TraversableOptional and TraversableIterable for adapting Optional and Iterable, respectively, to Traversable
• sequence for wrapping a traversable in an applicative during traversal
• Compose, an applicative functor that represents type-level functor composition

• CoProductN.[a-e]() static factory methods moved to equivalent ChoiceN class. Coproduct interfaces now solely represent methods, no longer have anonymous implementations, and no longer require a Functor constraint

• ChoiceN types, representing concrete coproduct implementations that are also Functor and BiFunctor
• toMap, last, cons, prependAll, intersperse
• Tuple2/3/4#into, for applying the values in a tuple as positional arguments to a function.
• First and Last monoids over Optional
• And and Or monoids over Boolean

• semigroups and monoids moved under fn2 package

• CoProductN#project, to project disjoint union types into tuples of Optional values
• CoProductN#converge, to drop the magnitude of a coproduct down by one type
• toCollection and size

• Fn1/2#adapt to switch between lambda and java.util.function types more easily
• eq, head, find, and tail
• BiPredicate
• Monoid#foldMap
• HMap#toMap to go from a heterogeneous map to a java.util.Map

• Semigroup and Monoid
• Either#invert
• partition
• Generalized coproducts implemented as CoProduct2 through CoProduct5
• Either is now a CoProduct2

• Lens static factory method renaming

• Heterogeneous list indexes arrive via Index

• Independent Lens parameter mapping via mapS, mapT, mapA, and mapB

• Initial lens support with Lens and SimpleLens types and view, set, and over functions
• Const and Identity functors
• Either#toOptional
• HMap#remove and HMap#removeAll

• All function input values become java.util.function types, and all function output values remain lambda types, for better compatibility

• Profunctor inheritance hierarchy
• Renaming Identity to Id
• Monadic/Dyadic/TriadicFunction is now Fn1/2/3

• HList specializations support random access lookup

• Tuples moved under HList as specialized subtypes

• Either#peek
• HMap, heterogeneous maps
• Tuple2 is now also a Map.Entry

• Better interoperability between lambda and java.util.function types

• scanLeft
• HList, heterogeneous lists
• Added up to Tuple5
• Either, specialized coproduct with success/failure semantics

• Initial implementation of first-class curried functions
• all, any, cartesianProduct, cycle, drop, dropWhile, filter, foldLeft, foldRight, inGroupsOf, map, partial2, partial3, reduceLeft, reduceRight, repeat, take, takeWhile, unfoldr
• Monadic/Dyadic/TriadicFunction, Predicate, Tuple2, Tuple3
• Functor, BiFunctor, ProFunctor