Upgrading dartz 0.1 to 0.2
Breaking0.1.3 → 0.2.5Breaking3New10Changed3Fixed1Other2
BreakingUpgrade verdict
3 breaking changes.
In plain terms
- Anything relying on IO types or functions no longer works and must be replaced.
- Old short alias names for type class instances are gone; switch to the MP-suffixed names.
- Code that called traverseM from its old location must now use TraversableMonadOps.
Must act 3 items need code or config changes
What you must change
Breaking3
Removes the IO functionality.
IORemoves redundant type class instance aliases; use IListMP instead of IListA, and so on.
IListMPIListAMoves the traverseM operation to TraversableMonadOps.
traverseMTraversableMonadOpsAPI changes
Generated by DepDelta from published Dart source. Not mixed with prose notes.
- removed:
class IOOp<A>: abstract - removed:
class ListMonad extends MonadPlus<List> - removed:
class ListTraversable extends Traversable<List> - removed:
class MonadPlusOpsMonad<F extends MonadPlusOps> extends MonadPlus<F> - removed:
class Println extends IOOp<Unit> - removed:
class Readln extends IOOp<String> - removed:
ctor MonadPlusOpsMonad(this._pure, this._empty) - removed:
ctor Println(this._s) - removed:
function ios(IList<Free<IOOp, Unit>> ioList): Free<IOOp, Unit> - removed:
function println(Object o): Free<IOOp, Unit> - removed:
get Println.s: String - removed:
method ListMonad.bind(List fa, List f( a)): List - removed:
method ListMonad.empty(): List - removed:
method ListMonad.plus(List f1, List f2): List - removed:
method ListMonad.pure( a): List - removed:
method ListTraversable.traverse(Applicative gApplicative, List fas, f(_)) - removed:
method MonadPlusOpsMonad.ap(F fa, F ff): F - removed:
method MonadPlusOpsMonad.bind(F fa, F f(_)): F - removed:
method MonadPlusOpsMonad.empty(): F - removed:
method MonadPlusOpsMonad.map(F fa, f(_)): F - removed:
method MonadPlusOpsMonad.plus(F f1, F f2): F - removed:
method MonadPlusOpsMonad.pure(a): F - removed:
method Traversable.traverseM(Applicative gApplicative, Monad<F> fMonad, F fa, f(a)) - removed:
method TraversableOps.traverseM(Applicative gApplicative, Monad<F> fMonad, f(A a)) - removed:
variable EitherA: final Applicative<Either> - removed:
variable EitherF: final Functor<Either> - removed:
variable EitherFo: final Foldable<Either> - removed:
variable IHashMapF: final Functor<IHashMap> - removed:
variable IHashMapFo: final Foldable<IHashMap> - removed:
variable IListA: final Applicative<IList> - removed:
variable IListAP: final ApplicativePlus<IList> - removed:
variable IListF: final Functor<IList> - removed:
variable IListFo: final Foldable<IList> - removed:
variable IListM: final Monad<IList> - removed:
variable IMapF: final Functor<IMap> - removed:
variable IMapFo: final Foldable<IMap> - removed:
variable IOM: final Monad<Free<IOOp, dynamic>> - removed:
variable IVectorA: final Applicative<IVector> - removed:
variable IVectorAP: final ApplicativePlus<IVector> - removed:
variable IVectorF: final Functor<IVector> - removed:
variable IVectorFo: final Foldable<IVector> - removed:
variable IVectorM: final Monad<IVector> - removed:
variable ListA: final Applicative<List> - removed:
variable ListAP: final ApplicativePlus<List> - removed:
variable ListF: final Functor<List> - removed:
variable ListFo: final Foldable<List> - removed:
variable ListM: final Monad<List> - removed:
variable OptionA: final OptionMonadPlus - removed:
variable OptionAP: final OptionMonadPlus - removed:
variable OptionF: final OptionMonadPlus - removed:
variable OptionFo: final Foldable<Option> - removed:
variable OptionM: final OptionMonadPlus - removed:
variable readln: final Free<IOOp, String> - changed:
class Applicative<F>: abstract extends Functor<F> → class Applicative<F>: abstract implements Functor<F> - changed:
class ApplicativePlus<F>: abstract extends Applicative<F> implements PlusEmpty<F> → class ApplicativePlus<F>: abstract implements Applicative<F>, PlusEmpty<F> - changed:
class ApplicativePlusOps<F, A>: abstract extends ApplicativeOps<F, A> with PlusEmptyOps<F, A> → class ApplicativePlusOps<F, A>: abstract implements ApplicativeOps<F, A>, PlusEmptyOps<F, A> - changed:
class ComposedApplicative<F, G> extends Applicative<F> → class ComposedApplicative<F, G> extends Functor<F> with Applicative<F> - changed:
class ComposedMonad<F, G> extends Monad<F> → class ComposedMonad<F, G> extends Functor<F> with Applicative<F>, Monad<F> - changed:
class Either<L, R>: abstract extends TraversableOps<Either<L, dynamic>, R> with MonadOps<Either<L, dynamic>, R> → class Either<L, R>: abstract extends TraversableOps<Either , R> with FunctorOps<Either , R>, ApplicativeOps<Either , R>, MonadOps<Either , R>, TraversableMonadOps<Either , R> - changed:
class EitherTMonad<M> extends Monad<M> → class EitherTMonad<M> extends Functor<M> with Applicative<M>, Monad<M> - changed:
class EvaluationMonad<E, R, W, S> extends Monad<Evaluation<E, R, W, S, dynamic>> → class EvaluationMonad<E, R, W, S> extends Functor<Evaluation<E, R, W, S, dynamic>> with Applicative<Evaluation<E, R, W, S, dynamic>>, Monad<Evaluation<E, R, W, S, dynamic>> - changed:
class FutureMonad extends Monad<Future> → class FutureMonad extends Functor<Future> with Applicative<Future>, Monad<Future> - changed:
class IList<A>: abstract extends TraversableOps<IList, A> with MonadOps<IList, A>, MonadPlusOps<IList, A> → class IList<A>: abstract extends TraversableOps<IList, A> with FunctorOps<IList, A>, ApplicativeOps<IList, A>, ApplicativePlusOps<IList, A>, MonadOps<IList, A>, MonadPlusOps<IList, A>, TraversableMonadOps<IList, A>, TraversableMonadPlusOps<IList, A> - changed:
class IListTMonad<M> extends Monad<M> → class IListTMonad<M> extends Functor<M> with Applicative<M>, Monad<M> - changed:
class ISet<A> → class ISet<A> extends FoldableOps<ISet, A> - changed:
class IVector<A> extends TraversableOps<IVector, A> with FunctorOps<IVector, A>, ApplicativeOps<IVector, A>, MonadOps<IVector, A>, MonadPlusOps<IVector, A> → class IVector<A> extends TraversableOps<IVector, A> with FunctorOps<IVector, A>, ApplicativeOps<IVector, A>, ApplicativePlusOps<IVector, A>, MonadOps<IVector, A>, MonadPlusOps<IVector, A>, TraversableMonadOps<IVector, A>, TraversableMonadPlusOps<IVector, A> - changed:
class IdMonad extends Monad → class IdMonad extends Functor with Applicative, Monad - changed:
class ListTMonad<M> extends Monad<M> → class ListTMonad<M> extends Functor<M> with Applicative<M>, Monad<M> - changed:
class Monad<F>: abstract extends Applicative<F> → class Monad<F>: abstract implements Applicative<F> - changed:
class MonadOpsMonad<F extends MonadOps> extends Monad<F> → class MonadOpsMonad<F extends MonadOps> extends Functor<F> with Applicative<F>, Monad<F> - changed:
class MonadPlus<F>: abstract extends Monad<F> implements ApplicativePlus<F> → class MonadPlus<F>: abstract implements Functor<F>, Applicative<F>, Monad<F>, ApplicativePlus<F> - changed:
class Option<A>: abstract extends TraversableOps<Option, A> with MonadOps<Option, A>, MonadPlusOps<Option, A> → class Option<A>: abstract extends TraversableOps<Option, A> with FunctorOps<Option, A>, ApplicativeOps<Option, A>, ApplicativePlusOps<Option, A>, MonadOps<Option, A>, MonadPlusOps<Option, A>, TraversableMonadOps<Option, A>, TraversableMonadPlusOps<Option, A> - changed:
class OptionMonadPlus extends MonadPlusOpsMonad<Option> → class OptionMonadPlus extends MonadPlusOpsMonadPlus<Option> - changed:
class OptionTMonad<M> extends Monad<M> → class OptionTMonad<M> extends Functor<M> with Applicative<M>, Monad<M> - changed:
class StateTMonad<F, S> extends Monad<StateT<F, S, dynamic>> → class StateTMonad<F, S> extends Functor<StateT<F, S, dynamic>> with Applicative<StateT<F, S, dynamic>>, Monad<StateT<F, S, dynamic>> - changed:
method Bind.foldMap(Monad G, f(_)) → method Bind.foldMap(Monad gMonad, f(_)) - changed:
method Free.foldMap(Monad G, f(_)) → method Free.foldMap(Monad gMonad, f(_)) - changed:
method IVector.set(int i, A a): Option<IVector<A>> → method IVector.set(int index, A a): Option<IVector<A>> - changed:
method OptionMonadPlus.map2(Option fa, Option fb, fun( a, b)): Option → method OptionMonadPlus.map2(Option fa, Option fb, Function2 fun): Option - changed:
method Pure.foldMap(Monad G, f(_)) → method Pure.foldMap(Monad gMonad, f(_)) - changed:
variable EitherM: final Monad<Either> → variable EitherM: final EitherMonad - changed:
variable IdTr: final Traversable → variable IdTr: final IdTraversable - changed:
variable ListMP: final MonadPlus<List> → variable ListMP: final ListTraversableMonadPlus - added:
class EitherMonad<L> extends MonadOpsMonad<Either<L, dynamic>> - added:
class ListTraversableMonadPlus extends Traversable<List> with Applicative<List>, ApplicativePlus<List>, Monad<List>, MonadPlus<List>, TraversableMonad<List>, TraversableMonadPlus<List> - added:
class MonadCatch<F>: abstract implements Monad<F> - added:
class MonadCatchOps<F, A>: abstract implements MonadOps<F, A> - added:
class MonadPlusOpsMonadPlus<F extends MonadPlusOps> extends Functor<F> with Applicative<F>, ApplicativePlus<F>, Monad<F>, MonadPlus<F> - added:
class Task<A> extends FunctorOps<Task, A> with ApplicativeOps<Task, A>, MonadOps<Task, A>, MonadCatchOps<Task, A> - added:
class TaskMonadCatch extends Functor<Task> with Applicative<Task>, Monad<Task>, MonadCatch<Task> - added:
class TraversableMonad<F>: abstract implements Traversable<F>, Monad<F> - added:
class TraversableMonadOps<F, A>: abstract implements TraversableOps<F, A>, MonadOps<F, A> - added:
class TraversableMonadPlus<F>: abstract implements Traversable<F>, MonadPlus<F> - added:
class TraversableMonadPlusOps<F, A>: abstract implements TraversableOps<F, A>, MonadPlusOps<F, A> - added:
ctor EitherMonad() - added:
ctor MonadPlusOpsMonadPlus(this._pure, this._empty) - added:
ctor Task(this._run) - added:
function eitherM(): EitherMonad - added:
function ihashmap(Map m): IHashMap - added:
function ilistMP(): MonadPlus<IList > - added:
function ivectorMP(): MonadPlus<IVector > - added:
function listMP(): MonadPlus<List > - added:
function optionMP(): MonadPlus<Option > - added:
function optionMi(Semigroup si): Monoid<Option > - added:
method ApplicativePlus.appendElement(F fa, a): F - added:
method ApplicativePlus.prependElement(F fa, a): F - added:
method ApplicativePlusOps.appendElement(A a): F - added:
method ApplicativePlusOps.prependElement(A a): F - added:
method EitherMonad.map2(Either<L, dynamic > fa, Either<L, dynamic > fb, fun( a, b)): Either<L, dynamic > - added:
method EitherMonad.map3(Either<L, dynamic > fa, Either<L, dynamic > fb, Either<L, dynamic > fc, fun( a, b, c)): Either<L, dynamic > - added:
method EitherMonad.map4(Either<L, dynamic > fa, Either<L, dynamic > fb, Either<L, dynamic > fc, Either<L, dynamic > fd, fun( a, b, c, d)): Either<L, dynamic > - added:
method EitherMonad.map5(Either<L, dynamic > fa, Either<L, dynamic > fb, Either<L, dynamic > fc, Either<L, dynamic > fd, Either<L, dynamic > fe, fun( a, b, c, d, e)): Either<L, dynamic > - added:
method EitherMonad.map6(Either<L, dynamic > fa, Either<L, dynamic > fb, Either<L, dynamic > fc, Either<L, dynamic > fd, Either<L, dynamic > fe, Either<L, dynamic > ff, fun( a, b, c, d, e, f)): Either<L, dynamic > - added:
method Evaluation.andThen(Evaluation<E, R, W, S, dynamic > next): Evaluation<E, R, W, S, dynamic > - added:
method EvaluationMonad.liftOption(Option oa, E ifNone()): Evaluation<E, R, W, S, dynamic > - added:
method Foldable.foldMapM(Monad m, Monoid bMonoid, F fa, f(a)) - added:
method FoldableOps.foldMapM(Monad m, Monoid bMonoid, f(A a)) - added:
method Free.andThen(Free next): Free - added:
method IList.appendElement(A a): IList<A> - added:
method IList.partition(bool f(A a)): Tuple2<IList<A>, IList<A>> - added:
method IList.prependElement(A a): IList<A> - added:
method IList.sort(Order<A> oa): IList<A> - added:
method IList.uncons( z(), f(A head, IList<A> tail)) - added:
method IList.unconsO( f(A head, IList<A> tail)): Option - added:
method ISet.foldLeft( z, f( previous, A a)) - added:
method ISet.foldMap(Monoid bMonoid, f(A a)) - added:
method ISet.foldRight( z, f(A a, previous)) - added:
method ListTraversableMonadPlus.bind(List fa, List f( a)): List - added:
method ListTraversableMonadPlus.empty(): List - added:
method ListTraversableMonadPlus.plus(List f1, List f2): List - added:
method ListTraversableMonadPlus.pure( a): List - added:
method ListTraversableMonadPlus.traverse(Applicative gApplicative, List fas, f(_)) - added:
method MonadCatch.attempt(F fa): F - added:
method MonadCatch.fail(Object err): F - added:
method MonadCatchOps.attempt(): F - added:
method MonadCatchOps.fail(Object err): F - added:
method MonadPlusOpsMonadPlus.ap(F fa, F ff): F - added:
method MonadPlusOpsMonadPlus.bind(F fa, F f(_)): F - added:
method MonadPlusOpsMonadPlus.empty(): F - added:
method MonadPlusOpsMonadPlus.map(F fa, f(_)): F - added:
method MonadPlusOpsMonadPlus.plus(F f1, F f2): F - added:
method MonadPlusOpsMonadPlus.pure(a): F - added:
method StateTMonad.withState(StateT<F, S, dynamic > f(S s)): StateT<F, S, dynamic > - added:
method Task.attempt(): Task<Either<Object, A>> - added:
method Task.bind(Task f(A a)): Task - added:
method Task.fail(Object err): Task<A> - added:
method Task.pure( b): Task - added:
method Task.run(): Future<A> - added:
method TaskMonadCatch.attempt(Task fa): Task<Either<Object, dynamic >> - added:
method TaskMonadCatch.bind(Task fa, Task f( a)): Task - added:
method TaskMonadCatch.fail(Object err): Task - added:
method TaskMonadCatch.pure( a): Task - added:
method TraversableMonad.traverseM(Applicative gApplicative, F fa, f(a)) - added:
method TraversableMonadOps.traverseM(Applicative gApplicative, f(A a)) - added:
method TraversableMonadPlus.partition(F fa, bool f( a)): Tuple2<F, F> - added:
method TraversableMonadPlusOps.partition(bool f(A a)): Tuple2<F, F> - added:
static method Task.delay(Function0 f): Task - added:
variable ISetFo: final Foldable<ISet> - added:
variable TaskMC: final MonadCatch<Task>