Skip to content

Instantly share code, notes, and snippets.

@retronym

retronym/shell.sh

Last active August 29, 2015 14:01
Show Gist options
  • Star 0 You must be signed in to star a gist
  • Fork 0 You must be signed in to fork a gist
  • Save retronym/e70833f5b34615b142c3 to your computer and use it in GitHub Desktop.
Save retronym/e70833f5b34615b142c3 to your computer and use it in GitHub Desktop.
Download ZIP
950 scalac-hash v2.11.0-RC1~68 -Ytyper-debug -Xprint:typer -classpath /Users/jason/.ivy2/cache/org.scalaz/scalaz-core_2.11/jars/scalaz-core_2.11-7.0.6.jar sandbox/unapply.scala 2>&1 | tee sandbox/68.log 951 scalac-hash v2.11.0-RC1~66 -Ytyper-debug -Xprint:typer -classpath /Users/jason/.ivy2/cache/org.scalaz/scalaz-core_2.11/jars/scalaz-core_2.1…
Raw
shell.sh
% for i in 67 66; do scalac-hash v2.11.0-RC1~$i -Ytyper-debug -Xprint:typer -classpath /Users/jason/.ivy2/cache/org.scalaz/scalaz-core_2.11/jars/scalaz-core_2.11-7.0.6.jar sandbox/unapply.scala 2>&1 | tee sandbox/68.log 951 scalac-hash v2.11.0-RC1~66 -Ytyper-debug -Xprint:typer -classpath /Users/jason/.ivy2/cache/org.scalaz/scalaz-core_2.11/jars/scalaz-core_2.11-7.0.6.jar sandbox/unapply.scala 2>&1 | tee sandbox/$i.log
% diff -u sandbox/{67,66}.log | subl
Raw
typer-log.diff
--- sandbox/67.log 2014-05-22 10:50:38.000000000 +0200
+++ sandbox/66.log 2014-05-22 10:51:03.000000000 +0200
@@ -1,461 +1,460 @@
|-- unapplybug EXPRmode-POLYmode-QUALmode (site: package <root>)
| \-> unapplybug.type
|-- scalaz EXPRmode-POLYmode-QUALmode (site: package unapplybug)
| \-> scalaz.type
|-- scalaz.std.option EXPRmode-POLYmode-QUALmode (site: package unapplybug)
| |-- scalaz.std EXPRmode-POLYmode-QUALmode (site: package unapplybug)
| | |-- scalaz EXPRmode-POLYmode-QUALmode (site: package unapplybug)
| | | \-> scalaz.type
| | \-> scalaz.std.type
| \-> scalaz.std.option.type
|-- scalaz.std.string EXPRmode-POLYmode-QUALmode (site: package unapplybug)
| |-- scalaz.std EXPRmode-POLYmode-QUALmode (site: package unapplybug)
| | |-- scalaz EXPRmode-POLYmode-QUALmode (site: package unapplybug)
| | | \-> scalaz.type
| | \-> scalaz.std.type
| \-> scalaz.std.string.type
|-- class UnapplyAux[TC[_[_]], FA, F[_], A] BYVALmode-EXPRmode (site: package unapplybug)
| |-- def TC BYVALmode-EXPRmode (site: trait UnapplyAux)
| | |-- TC[F] TYPEmode (site: method TC in UnapplyAux)
| | | |-- F NOmode (site: method TC in UnapplyAux)
| | | | \-> F
| | | \-> TC[F]
| | |-- TC[_] TYPEmode (site: method TC in UnapplyAux)
| | | \-> TC[F]
| | \-> [def TC] => TC[F]
| |-- def apply BYVALmode-EXPRmode (site: trait UnapplyAux)
| | |-- F[A] TYPEmode (site: method apply in UnapplyAux)
| | | |-- A TYPEmode (site: method apply in UnapplyAux)
| | | | \-> A
| | | \-> F[A]
| | |-- FA TYPEmode (site: value fa in UnapplyAux)
| | | \-> FA
| | |-- F[_] TYPEmode (site: method apply in UnapplyAux)
| | | \-> F[A]
| | \-> [def apply] (fa: FA)F[A]
| \-> [trait UnapplyAux] unapplybug.UnapplyAux[TC,FA,F,A]
|-- object UnapplyAux BYVALmode-EXPRmode (site: package unapplybug)
| |-- super EXPRmode-POLYmode-QUALmode (silent: <init> in UnapplyAux)
| | |-- this EXPRmode (silent: <init> in UnapplyAux)
| | | \-> unapplybug.UnapplyAux.type
| | \-> unapplybug.UnapplyAux.type
| |-- def unapplyAux[TC[_[_]], FA] BYVALmode-EXPRmode (site: object UnapplyAux)
| | |-- UnapplyAux[TC, FA, ev.M, ev.A] TYPEmode (site: method unapplyAux in UnapplyAux)
| | | |-- TC NOmode (site: method unapplyAux in UnapplyAux)
| | | | \-> TC
| | | |-- FA TYPEmode (site: method unapplyAux in UnapplyAux)
| | | | \-> FA
| | | |-- ev.M NOmode (site: method unapplyAux in UnapplyAux)
| | | | |-- ev EXPRmode-POLYmode-QUALmode (site: method unapplyAux in UnapplyAux)
| | | | | |-- Unapply[TC, FA] TYPEmode (site: value ev in UnapplyAux)
| | | | | | |-- TC NOmode (site: value ev in UnapplyAux)
| | | | | | | \-> TC
| | | | | | |-- FA TYPEmode (site: value ev in UnapplyAux)
| | | | | | | \-> FA
| | | | | | \-> scalaz.Unapply[TC,FA]
| | | | | \-> ev.type (with underlying type scalaz.Unapply[TC,FA])
| | | | \-> ev.M
| | | |-- ev.A TYPEmode (site: method unapplyAux in UnapplyAux)
| | | | |-- ev EXPRmode-POLYmode-QUALmode (site: method unapplyAux in UnapplyAux)
| | | | | \-> ev.type (with underlying type scalaz.Unapply[TC,FA])
| | | | \-> ev.A
| | | \-> unapplybug.UnapplyAux[TC,FA,ev.M,ev.A]
| | |-- Unapply[TC, FA] TYPEmode (site: value ev in UnapplyAux)
| | | \-> scalaz.Unapply[TC,FA]
| | |-- unapplybug.UnapplyAux[TC,FA,F,A] TYPEmode (site: method unapplyAux in UnapplyAux)
| | | \-> unapplybug.UnapplyAux[TC,FA,ev.M,ev.A]
| | |-- { final class $anon extends UnapplyAux[TC, FA, ev.M, ev.A... : pt=unapplybug.UnapplyAux[TC,FA,ev.M,ev.A] EXPRmode (site: method unapplyAux in UnapplyAux)
| | | |-- UnapplyAux FUNmode-TYPEmode (site: anonymous class $anon)
| | | | \-> unapplybug.UnapplyAux
| | | |-- UnapplyAux[TC, FA, ev.M, ev.A] TYPEmode (site: anonymous class $anon)
| | | | |-- TC NOmode (site: anonymous class $anon)
| | | | | \-> TC
| | | | |-- FA TYPEmode (site: anonymous class $anon)
| | | | | \-> FA
| | | | |-- ev.M NOmode (site: anonymous class $anon)
| | | | | |-- ev EXPRmode-POLYmode-QUALmode (site: anonymous class $anon)
| | | | | | \-> ev.type (with underlying type scalaz.Unapply[TC,FA])
| | | | | \-> ev.M
| | | | |-- ev.A TYPEmode (site: anonymous class $anon)
| | | | | |-- ev EXPRmode-POLYmode-QUALmode (site: anonymous class $anon)
| | | | | | \-> ev.type (with underlying type scalaz.Unapply[TC,FA])
| | | | | \-> ev.A
| | | | \-> unapplybug.UnapplyAux[TC,FA,ev.M,ev.A]
| | | |-- ev.TC : pt=TC[ev.M] EXPRmode (site: method TC in $anon)
| | | | |-- ev EXPRmode-POLYmode-QUALmode (site: method TC in $anon)
| | | | | \-> ev.type (with underlying type scalaz.Unapply[TC,FA])
| | | | \-> TC[ev.M]
| | | |-- FA TYPEmode (site: value fa in $anon)
| | | | \-> FA
| | | |-- ev(fa) : pt=ev.M[ev.A] EXPRmode (site: method apply in $anon)
| | | | |-- ev BYVALmode-EXPRmode-FUNmode-POLYmode (silent: method apply in $anon)
| | | | | |-- ev.apply BYVALmode-EXPRmode-FUNmode-POLYmode (silent: method apply in $anon)
| | | | | | \-> (ma: FA)ev.M[ev.A]
| | | | | [adapt] scalaz.Unapply[TC,FA] adapted to (ma: MA)Unapply.this.M[Unapply.this.A]
| | | | | \-> (ma: FA)ev.M[ev.A]
| | | | |-- fa : pt=FA BYVALmode-EXPRmode (silent: method apply in $anon)
| | | | | \-> FA
| | | | \-> ev.M[ev.A]
| | | |-- class $anon BYVALmode-EXPRmode (site: method unapplyAux in UnapplyAux)
| | | | |-- unapplybug.UnapplyAux[TC,FA,F,A] TYPEmode (site: anonymous class $anon)
| | | | | \-> unapplybug.UnapplyAux[TC,FA,ev.M,ev.A]
| | | | |-- super EXPRmode-POLYmode-QUALmode (silent: <init> in $anon)
| | | | | |-- this EXPRmode (silent: <init> in $anon)
| | | | | | \-> unapplybug.UnapplyAux[TC,FA,ev.M,ev.A]
| | | | | \-> super.type (with underlying type AnyRef)
| | | | |-- def TC BYVALmode-EXPRmode (site: anonymous class $anon)
| | | | | \-> [def TC] => TC[ev.M]
| | | | |-- def apply BYVALmode-EXPRmode (site: anonymous class $anon)
| | | | | \-> [def apply] (fa: FA)ev.M[ev.A]
| | | | \-> [class $anon] unapplybug.UnapplyAux[TC,FA,ev.M,ev.A]
| | | |-- new $anon() : pt=unapplybug.UnapplyAux[TC,FA,ev.M,ev.A] EXPRmode (site: method unapplyAux in UnapplyAux)
| | | | |-- new $anon BYVALmode-EXPRmode-FUNmode-POLYmode (silent: method unapplyAux in UnapplyAux)
| | | | | |-- new $anon EXPRmode-POLYmode-QUALmode (silent: method unapplyAux in UnapplyAux)
| | | | | | |-- $anon FUNmode-TYPEmode (silent: method unapplyAux in UnapplyAux)
| | | | | | | \-> unapplybug.UnapplyAux[TC,FA,ev.M,ev.A]
| | | | | | \-> unapplybug.UnapplyAux[TC,FA,ev.M,ev.A]
| | | | | \-> ()unapplybug.UnapplyAux[TC,FA,ev.M,ev.A]
| | | | \-> unapplybug.UnapplyAux[TC,FA,ev.M,ev.A]
| | | \-> unapplybug.UnapplyAux[TC,FA,ev.M,ev.A]
| | \-> [def unapplyAux] [TC[_[_]], FA](implicit ev: scalaz.Unapply[TC,FA])unapplybug.UnapplyAux[TC,FA,ev.M,ev.A]
| \-> [object UnapplyAux] unapplybug.UnapplyAux.type
|-- object UnapplyBug BYVALmode-EXPRmode (site: package unapplybug)
| |-- Option(23) EXPRmode (site: value oi in UnapplyBug)
| | |-- Option BYVALmode-EXPRmode-FUNmode-POLYmode (silent: value oi in UnapplyBug)
| | | |-- scala.Option.apply BYVALmode-EXPRmode-FUNmode-POLYmode (silent: value oi in UnapplyBug)
| | | | [adapt] [A](x: A)Option[A] adapted to [A](x: A)Option[A]
| | | | \-> (x: A)Option[A]
| | | [adapt] Option.type adapted to [A](x: A)Option[A]
| | | \-> (x: A)Option[A]
| | |-- 23 BYVALmode-EXPRmode-POLYmode (site: value oi in UnapplyBug)
| | | \-> Int(23)
| | solving for (A: ?A)
| | \-> Option[Int]
| |-- Validation[String, Int] TYPEmode (site: value vis in UnapplyBug)
| | |-- String TYPEmode (site: value vis in UnapplyBug)
| | | [adapt] String is now a TypeTree(String)
| | | \-> String
| | |-- Int TYPEmode (site: value vis in UnapplyBug)
| | | \-> Int
| | \-> scalaz.Validation[String,Int]
| |-- Validation[String, Int] TYPEmode (site: value vis in UnapplyBug)
| | |-- String TYPEmode (site: value vis in UnapplyBug)
| | | [adapt] String is now a TypeTree(String)
| | | \-> String
| | |-- Int TYPEmode (site: value vis in UnapplyBug)
| | | \-> Int
| | \-> scalaz.Validation[String,Int]
| |-- super EXPRmode-POLYmode-QUALmode (silent: <init> in UnapplyBug)
| | |-- this EXPRmode (silent: <init> in UnapplyBug)
| | | \-> unapplybug.UnapplyBug.type
| | \-> unapplybug.UnapplyBug.type
| |-- def mkUnapply[FA] BYVALmode-EXPRmode (site: object UnapplyBug)
| | |-- Unapply[Functor, FA] { type M[x] = un.M[x]; type A = un.A } TYPEmode (site: method mkUnapply in UnapplyBug)
| | | |-- Unapply[Functor, FA] TYPEmode (site: method mkUnapply in UnapplyBug)
| | | | |-- Functor NOmode (site: method mkUnapply in UnapplyBug)
| | | | | \-> scalaz.Functor
| | | | |-- FA TYPEmode (site: method mkUnapply in UnapplyBug)
| | | | | \-> FA
| | | | \-> scalaz.Unapply[scalaz.Functor,FA]
| | | |-- un.M[x] TYPEmode (site: type M in <refinement>)
| | | | |-- un EXPRmode-POLYmode-QUALmode (site: type M in <refinement>)
| | | | | |-- Unapply[Functor, FA] TYPEmode (site: value un in UnapplyBug)
| | | | | | |-- Functor NOmode (site: value un in UnapplyBug)
| | | | | | | \-> scalaz.Functor
| | | | | | |-- FA TYPEmode (site: value un in UnapplyBug)
| | | | | | | \-> FA
| | | | | | \-> scalaz.Unapply[scalaz.Functor,FA]
| | | | | \-> un.type (with underlying type scalaz.Unapply[scalaz.Functor,FA])
| | | | |-- x TYPEmode (site: type M in <refinement>)
| | | | | \-> x
| | | | \-> un.M[x]
| | | |-- un.A TYPEmode (site: type A in <refinement>)
| | | | |-- un EXPRmode-POLYmode-QUALmode (site: type A in <refinement>)
| | | | | \-> un.type (with underlying type scalaz.Unapply[scalaz.Functor,FA])
| | | | \-> un.A
| | | [adapt] Unapply[Functor, FA] { type M[x] = un.M[x]; type A = un.A } is now a TypeTree(scalaz.Unapply[scalaz.Functor,FA]{type M[x] = un.M[x]; type A = un.A})
| | | \-> scalaz.Unapply[scalaz.Functor,FA]{type M[x] = un.M[x]; type A = un.A}
| | |-- FA TYPEmode (site: value f in UnapplyBug)
| | | \-> FA
| | |-- Unapply[Functor, FA] TYPEmode (site: value un in UnapplyBug)
| | | |-- Functor NOmode (site: value un in UnapplyBug)
| | | | \-> scalaz.Functor
| | | \-> scalaz.Unapply[scalaz.Functor,FA]
| | |-- un : pt=scalaz.Unapply[scalaz.Functor,FA]{type M[x] = un.M[x]; type A = un.A} EXPRmode (site: method mkUnapply in UnapplyBug)
| | | \-> un.type (with underlying type scalaz.Unapply[scalaz.Functor,FA])
| | \-> [def mkUnapply] [FA](f: FA)(implicit un: scalaz.Unapply[scalaz.Functor,FA])scalaz.Unapply[scalaz.Functor,FA]{type M[x] = un.M[x]; type A = un.A}
| |-- def mkUnapplyAux[FA, F[_], A] BYVALmode-EXPRmode (site: object UnapplyBug)
| | |-- UnapplyAux[Functor, FA, F, A] TYPEmode (site: method mkUnapplyAux in UnapplyBug)
| | | |-- Functor NOmode (site: method mkUnapplyAux in UnapplyBug)
| | | | \-> scalaz.Functor
| | | |-- FA TYPEmode (site: method mkUnapplyAux in UnapplyBug)
| | | | \-> FA
| | | |-- F NOmode (site: method mkUnapplyAux in UnapplyBug)
| | | | \-> F
| | | |-- A TYPEmode (site: method mkUnapplyAux in UnapplyBug)
| | | | \-> A
| | | \-> unapplybug.UnapplyAux[scalaz.Functor,FA,F,A]
| | |-- FA TYPEmode (site: value f in UnapplyBug)
| | | \-> FA
| | |-- UnapplyAux[Functor, FA, F, A] TYPEmode (site: value un in UnapplyBug)
| | | |-- Functor NOmode (site: value un in UnapplyBug)
| | | | \-> scalaz.Functor
| | | |-- FA TYPEmode (site: value un in UnapplyBug)
| | | | \-> FA
| | | |-- F NOmode (site: value un in UnapplyBug)
| | | | \-> F
| | | |-- A TYPEmode (site: value un in UnapplyBug)
| | | | \-> A
| | | \-> unapplybug.UnapplyAux[scalaz.Functor,FA,F,A]
| | |-- unapplybug.UnapplyAux[TC,FA,F,A] TYPEmode (site: value un in UnapplyBug)
| | | |-- Functor NOmode (site: value un in UnapplyBug)
| | | | \-> scalaz.Functor
| | | \-> unapplybug.UnapplyAux[scalaz.Functor,FA,F,A]
| | |-- unapplybug.UnapplyAux[TC,FA,F,A] TYPEmode (site: method mkUnapplyAux in UnapplyBug)
| | | |-- Functor NOmode (site: method mkUnapplyAux in UnapplyBug)
| | | | \-> scalaz.Functor
| | | \-> unapplybug.UnapplyAux[scalaz.Functor,FA,F,A]
| | |-- un : pt=unapplybug.UnapplyAux[scalaz.Functor,FA,F,A] EXPRmode (site: method mkUnapplyAux in UnapplyBug)
| | | \-> unapplybug.UnapplyAux[scalaz.Functor,FA,F,A]
| | \-> [def mkUnapplyAux] [FA, F[_], A](f: FA)(implicit un: unapplybug.UnapplyAux[scalaz.Functor,FA,F,A])unapplybug.UnapplyAux[scalaz.Functor,FA,F,A]
| |-- Option[Int] BYVALmode-EXPRmode (site: object UnapplyBug)
| | \-> [val oi ] Option[Int]
| |-- def oi BYVALmode-EXPRmode (site: object UnapplyBug)
| | |-- Option[Int] : pt=Option[Int] EXPRmode (site: value oi in UnapplyBug)
| | | |-- unapplybug.UnapplyBug.type EXPRmode-POLYmode-QUALmode (site: value oi in UnapplyBug)
| | | | \-> unapplybug.UnapplyBug.type
| | | \-> Option[Int]
| | \-> [def oi] => Option[Int]
| |-- scalaz.Validation[String,Int] BYVALmode-EXPRmode (site: object UnapplyBug)
| | |-- Validation[String, Int] TYPEmode (site: value vis in UnapplyBug)
| | | |-- String TYPEmode (site: value vis in UnapplyBug)
| | | | [adapt] String is now a TypeTree(String)
| | | | \-> String
| | | |-- Int TYPEmode (site: value vis in UnapplyBug)
| | | | \-> Int
| | | \-> scalaz.Validation[String,Int]
| | |-- Success(13) : pt=scalaz.Validation[String,Int] BYVALmode-EXPRmode (site: value vis in UnapplyBug)
| | | |-- Success BYVALmode-EXPRmode-FUNmode-POLYmode (silent: value vis in UnapplyBug)
| | | | |-- scalaz.Success.apply BYVALmode-EXPRmode-FUNmode-POLYmode (silent: value vis in UnapplyBug)
| | | | | [adapt] [E, A](a: A)scalaz.Success[E,A] adapted to [E, A](a: A)scalaz.Success[E,A]
| | | | | \-> (a: A)scalaz.Success[E,A]
| | | | [adapt] scalaz.Success.type adapted to [E, A](a: A)scalaz.Success[E,A]
| | | | \-> (a: A)scalaz.Success[E,A]
| | | |-- 13 : pt=Int BYVALmode-EXPRmode-POLYmode (site: value vis in UnapplyBug)
| | | | \-> Int(13)
| | | solving for (E: ?E, A: ?A)
| | | solving for (E: ?E)
| | | \-> scalaz.Success[Nothing,Int]
| | \-> [val vis ] scalaz.Validation[String,Int]
| |-- def vis BYVALmode-EXPRmode (site: object UnapplyBug)
| | |-- scalaz.Validation[String,Int] : pt=scalaz.Validation[String,Int] EXPRmode (site: value vis in UnapplyBug)
| | | |-- unapplybug.UnapplyBug.type EXPRmode-POLYmode-QUALmode (site: value vis in UnapplyBug)
| | | | \-> unapplybug.UnapplyBug.type
| | | \-> scalaz.Validation[String,Int]
| | \-> [def vis] => scalaz.Validation[String,Int]
| |-- mkUnapply(oi) BYVALmode-EXPRmode (site: value <local UnapplyBug> in UnapplyBug)
| | |-- mkUnapply BYVALmode-EXPRmode-FUNmode-POLYmode (silent: value <local UnapplyBug> in UnapplyBug)
| | | [adapt] [FA](f: FA)(implicit un: scalaz.Unapply[scalaz.Functor,FA... adapted to [FA](f: FA)(implicit un: scalaz.Unapply[scalaz.Functor,FA...
| | | \-> (f: FA)(implicit un: scalaz.Unapply[scalaz.Functor,FA])scalaz.Unapply[scalaz.Functor,FA]{type M[x] = un.M[x]; type A = un.A}
| | |-- oi BYVALmode-EXPRmode-POLYmode (site: value <local UnapplyBug> in UnapplyBug)
| | | \-> Option[Int]
| | solving for (FA: ?FA)
| | solving for (TC: ?TC, M0: ?M0, A0: ?A0)
| | [adapt] optionInstance adapted to => scalaz.Traverse[Option] with scalaz.MonadPlus[Option] ... based on pt scalaz.Functor[Option]
| | |-- [TC[_[_]], M0[_], A0](implicit TC0: TC[M0])scalaz.Unapply... : pt=scalaz.Unapply[scalaz.Functor,Option[Int]] EXPRmode (silent: value <local UnapplyBug> in UnapplyBug) implicits disabled
| | | \-> scalaz.Unapply[scalaz.Functor,Option[Int]]{type M[X] = Option[X]; type A = Int}
| | [adapt] [TC[_[_]], M0[_], A0](implicit TC0: TC[M0])scalaz.Unapply... adapted to [TC[_[_]], M0[_], A0](implicit TC0: TC[M0])scalaz.Unapply... based on pt scalaz.Unapply[scalaz.Functor,Option[Int]]
| | |-- [FA](f: FA)(implicit un: scalaz.Unapply[scalaz.Functor,FA... BYVALmode-EXPRmode (site: value <local UnapplyBug> in UnapplyBug)
| | | \-> scalaz.Unapply[scalaz.Functor,Option[Int]]{type M[x] = Option[x]; type A = Int}
| | [adapt] [FA](f: FA)(implicit un: scalaz.Unapply[scalaz.Functor,FA... adapted to [FA](f: FA)(implicit un: scalaz.Unapply[scalaz.Functor,FA...
| | \-> scalaz.Unapply[scalaz.Functor,Option[Int]]{type M[x] = Option[x]; type A = Int}
| |-- mkUnapply(vis) BYVALmode-EXPRmode (site: value <local UnapplyBug> in UnapplyBug)
| | |-- mkUnapply BYVALmode-EXPRmode-FUNmode-POLYmode (silent: value <local UnapplyBug> in UnapplyBug)
| | | [adapt] [FA](f: FA)(implicit un: scalaz.Unapply[scalaz.Functor,FA... adapted to [FA](f: FA)(implicit un: scalaz.Unapply[scalaz.Functor,FA...
| | | \-> (f: FA)(implicit un: scalaz.Unapply[scalaz.Functor,FA])scalaz.Unapply[scalaz.Functor,FA]{type M[x] = un.M[x]; type A = un.A}
| | |-- vis BYVALmode-EXPRmode-POLYmode (site: value <local UnapplyBug> in UnapplyBug)
| | | \-> scalaz.Validation[String,Int]
| | solving for (FA: ?FA)
| | [adapt] [TC[_[_]], M0[_], A0](implicit TC0: TC[M0])scalaz.Unapply... adapted to [TC[_[_]], M0[_], A0](implicit TC0: TC[M0])scalaz.Unapply... based on pt scalaz.Unapply[scalaz.Functor,scalaz.Validation[String,Int]]
| | solving for (TC: ?TC, M0: ?M0, A0: ?A0, B0: ?B0)
| | solving for (L: ?L)
| | [adapt] [L]=> scalaz.Traverse[[a]scalaz.Validation[L,a]] with sca... adapted to [L]=> scalaz.Traverse[[a]scalaz.Validation[L,a]] with sca... based on pt scalaz.Functor[[?]scalaz.Validation[String,?]]
| | |-- [TC[_[_]], M0[_, _], A0, B0](implicit TC0: TC[[?]M0[A0,?]... : pt=scalaz.Unapply[scalaz.Functor,scalaz.Validation[String,Int]] EXPRmode (silent: value <local UnapplyBug> in UnapplyBug) implicits disabled
| | | \-> scalaz.Unapply[scalaz.Functor,scalaz.Validation[String,Int]]{type M[X] = scalaz.Validation[String,X]; type A = Int}
| | [adapt] [TC[_[_]], M0[_, _], A0, B0](implicit TC0: TC[[?]M0[A0,?]... adapted to [TC[_[_]], M0[_, _], A0, B0](implicit TC0: TC[[?]M0[A0,?]... based on pt scalaz.Unapply[scalaz.Functor,scalaz.Validation[String,Int]]
| | solving for (TC: ?TC, M0: ?M0, A0: ?A0, B0: ?B0)
| | |-- [TC[_[_]], M0[_, _], A0, B0](implicit TC0: TC[[?]M0[?,B0]... : pt=scalaz.Unapply[scalaz.Functor,scalaz.Validation[String,Int]] EXPRmode (silent: value <local UnapplyBug> in UnapplyBug) implicits disabled
| | | \-> <error>
| | [adapt] [TC[_[_]], M0[_, _], A0, B0](implicit TC0: TC[[?]M0[?,B0]... adapted to [TC[_[_]], M0[_, _], A0, B0](implicit TC0: TC[[?]M0[?,B0]... based on pt scalaz.Unapply[scalaz.Functor,scalaz.Validation[String,Int]]
| | [adapt] [TC[_[_]], M0[_[_], _], F0[_], A0](implicit TC0: TC[[?]M0... adapted to [TC[_[_]], M0[_[_], _], F0[_], A0](implicit TC0: TC[[?]M0... based on pt scalaz.Unapply[scalaz.Functor,scalaz.Validation[String,Int]]
| | |-- [FA](f: FA)(implicit un: scalaz.Unapply[scalaz.Functor,FA... BYVALmode-EXPRmode (site: value <local UnapplyBug> in UnapplyBug)
| | | \-> scalaz.Unapply[scalaz.Functor,scalaz.Validation[String,Int]]{type M[x] = scalaz.Validation[String,x]; type A = Int}
| | [adapt] [FA](f: FA)(implicit un: scalaz.Unapply[scalaz.Functor,FA... adapted to [FA](f: FA)(implicit un: scalaz.Unapply[scalaz.Functor,FA...
| | \-> scalaz.Unapply[scalaz.Functor,scalaz.Validation[String,Int]]{type M[x] = scalaz.Validation[String,x]; type A = Int}
| |-- mkUnapplyAux(oi) BYVALmode-EXPRmode (site: value <local UnapplyBug> in UnapplyBug)
| | |-- mkUnapplyAux BYVALmode-EXPRmode-FUNmode-POLYmode (silent: value <local UnapplyBug> in UnapplyBug)
| | | [adapt] [FA, F[_], A](f: FA)(implicit un: unapplybug.UnapplyAux[s... adapted to [FA, F[_], A](f: FA)(implicit un: unapplybug.UnapplyAux[s...
| | | \-> (f: FA)(implicit un: unapplybug.UnapplyAux[scalaz.Functor,FA,F,A])unapplybug.UnapplyAux[scalaz.Functor,FA,F,A]
| | |-- oi BYVALmode-EXPRmode-POLYmode (site: value <local UnapplyBug> in UnapplyBug)
| | | \-> Option[Int]
| | solving for (FA: ?FA, F: ?F, A: ?A)
| | solving for (F: ?F, A: ?A)
| | solving for (TC: ?TC, FA: ?FA)
| | solving for (TC: ?TC, M0: ?M0, A0: ?A0)
| | [adapt] optionInstance adapted to => scalaz.Traverse[Option] with scalaz.MonadPlus[Option] ... based on pt scalaz.Functor[Option]
| | |-- [TC[_[_]], M0[_], A0](implicit TC0: TC[M0])scalaz.Unapply... : pt=scalaz.Unapply[scalaz.Functor,Option[Int]] EXPRmode (silent: value <local UnapplyBug> in UnapplyBug) implicits disabled
| | | \-> scalaz.Unapply[scalaz.Functor,Option[Int]]{type M[X] = Option[X]; type A = Int}
| | [adapt] [TC[_[_]], M0[_], A0](implicit TC0: TC[M0])scalaz.Unapply... adapted to [TC[_[_]], M0[_], A0](implicit TC0: TC[M0])scalaz.Unapply... based on pt scalaz.Unapply[scalaz.Functor,Option[Int]]
| | |-- [TC[_[_]], FA](implicit ev: scalaz.Unapply[TC,FA])unapply... : pt=unapplybug.UnapplyAux[scalaz.Functor,Option[Int],?,?] EXPRmode (silent: value <local UnapplyBug> in UnapplyBug) implicits disabled
-| | | \-> unapplybug.UnapplyAux[scalaz.Functor,Option[Int],scalaz.Unapply[scalaz.Functor,Option[Int]]{type M[X] = Option[X]; type A = Int}#M,Int]
+| | | \-> unapplybug.UnapplyAux[scalaz.Functor,Option[Int],[X]Option[X],Int]
| | [adapt] [TC[_[_]], FA](implicit ev: scalaz.Unapply[TC,FA])unapply... adapted to [TC[_[_]], FA](implicit ev: scalaz.Unapply[TC,FA])unapply... based on pt unapplybug.UnapplyAux[scalaz.Functor,Option[Int],F,A]
| | solving for (F: ?F, A: ?A)
| | |-- [FA, F[_], A](f: FA)(implicit un: unapplybug.UnapplyAux[s... BYVALmode-EXPRmode (site: value <local UnapplyBug> in UnapplyBug)
-| | | \-> unapplybug.UnapplyAux[scalaz.Functor,Option[Int],scalaz.Unapply[scalaz.Functor,Option[Int]]{type M[X] = Option[X]; type A = Int}#M,Int]
+| | | \-> unapplybug.UnapplyAux[scalaz.Functor,Option[Int],Option,Int]
| | [adapt] [FA, F[_], A](f: FA)(implicit un: unapplybug.UnapplyAux[s... adapted to [FA, F[_], A](f: FA)(implicit un: unapplybug.UnapplyAux[s...
-| | \-> unapplybug.UnapplyAux[scalaz.Functor,Option[Int],scalaz.Unapply[scalaz.Functor,Option[Int]]{type M[X] = Option[X]; type A = Int}#M,Int]
+| | \-> unapplybug.UnapplyAux[scalaz.Functor,Option[Int],Option,Int]
| |-- mkUnapplyAux(vis) BYVALmode-EXPRmode (site: value <local UnapplyBug> in UnapplyBug)
| | |-- mkUnapplyAux BYVALmode-EXPRmode-FUNmode-POLYmode (silent: value <local UnapplyBug> in UnapplyBug)
| | | [adapt] [FA, F[_], A](f: FA)(implicit un: unapplybug.UnapplyAux[s... adapted to [FA, F[_], A](f: FA)(implicit un: unapplybug.UnapplyAux[s...
| | | \-> (f: FA)(implicit un: unapplybug.UnapplyAux[scalaz.Functor,FA,F,A])unapplybug.UnapplyAux[scalaz.Functor,FA,F,A]
| | |-- vis BYVALmode-EXPRmode-POLYmode (site: value <local UnapplyBug> in UnapplyBug)
| | | \-> scalaz.Validation[String,Int]
| | solving for (FA: ?FA, F: ?F, A: ?A)
| | solving for (F: ?F, A: ?A)
| | solving for (TC: ?TC, FA: ?FA)
| | [adapt] [TC[_[_]], M0[_], A0](implicit TC0: TC[M0])scalaz.Unapply... adapted to [TC[_[_]], M0[_], A0](implicit TC0: TC[M0])scalaz.Unapply... based on pt scalaz.Unapply[scalaz.Functor,scalaz.Validation[String,Int]]
| | solving for (TC: ?TC, M0: ?M0, A0: ?A0, B0: ?B0)
| | solving for (L: ?L)
| | [adapt] [L]=> scalaz.Traverse[[a]scalaz.Validation[L,a]] with sca... adapted to [L]=> scalaz.Traverse[[a]scalaz.Validation[L,a]] with sca... based on pt scalaz.Functor[[?]scalaz.Validation[String,?]]
| | |-- [TC[_[_]], M0[_, _], A0, B0](implicit TC0: TC[[?]M0[A0,?]... : pt=scalaz.Unapply[scalaz.Functor,scalaz.Validation[String,Int]] EXPRmode (silent: value <local UnapplyBug> in UnapplyBug) implicits disabled
| | | \-> scalaz.Unapply[scalaz.Functor,scalaz.Validation[String,Int]]{type M[X] = scalaz.Validation[String,X]; type A = Int}
| | [adapt] [TC[_[_]], M0[_, _], A0, B0](implicit TC0: TC[[?]M0[A0,?]... adapted to [TC[_[_]], M0[_, _], A0, B0](implicit TC0: TC[[?]M0[A0,?]... based on pt scalaz.Unapply[scalaz.Functor,scalaz.Validation[String,Int]]
| | solving for (TC: ?TC, M0: ?M0, A0: ?A0, B0: ?B0)
| | |-- [TC[_[_]], M0[_, _], A0, B0](implicit TC0: TC[[?]M0[?,B0]... : pt=scalaz.Unapply[scalaz.Functor,scalaz.Validation[String,Int]] EXPRmode (silent: value <local UnapplyBug> in UnapplyBug) implicits disabled
| | | \-> <error>
| | [adapt] [TC[_[_]], M0[_, _], A0, B0](implicit TC0: TC[[?]M0[?,B0]... adapted to [TC[_[_]], M0[_, _], A0, B0](implicit TC0: TC[[?]M0[?,B0]... based on pt scalaz.Unapply[scalaz.Functor,scalaz.Validation[String,Int]]
| | [adapt] [TC[_[_]], M0[_[_], _], F0[_], A0](implicit TC0: TC[[?]M0... adapted to [TC[_[_]], M0[_[_], _], F0[_], A0](implicit TC0: TC[[?]M0... based on pt scalaz.Unapply[scalaz.Functor,scalaz.Validation[String,Int]]
| | |-- [TC[_[_]], FA](implicit ev: scalaz.Unapply[TC,FA])unapply... : pt=unapplybug.UnapplyAux[scalaz.Functor,scalaz.Validation[String,Int],?,?] EXPRmode (silent: value <local UnapplyBug> in UnapplyBug) implicits disabled
-| | | \-> unapplybug.UnapplyAux[scalaz.Functor,scalaz.Validation[String,Int],scalaz.Unapply[scalaz.Functor,scalaz.Validation[String,Int]]{type M[X] = scalaz.Validation[String,X]; type A = Int}#M,Int]
+| | | \-> unapplybug.UnapplyAux[scalaz.Functor,scalaz.Validation[String,Int],[X]scalaz.Validation[String,X],Int]
| | [adapt] [TC[_[_]], FA](implicit ev: scalaz.Unapply[TC,FA])unapply... adapted to [TC[_[_]], FA](implicit ev: scalaz.Unapply[TC,FA])unapply... based on pt unapplybug.UnapplyAux[scalaz.Functor,scalaz.Validation[String,Int],F,A]
-| | solving for (F: ?F, A: ?A)
-| | |-- [FA, F[_], A](f: FA)(implicit un: unapplybug.UnapplyAux[s... BYVALmode-EXPRmode (site: value <local UnapplyBug> in UnapplyBug)
-| | | \-> unapplybug.UnapplyAux[scalaz.Functor,scalaz.Validation[String,Int],scalaz.Unapply[scalaz.Functor,scalaz.Validation[String,Int]]{type M[X] = scalaz.Validation[String,X]; type A = Int}#M,Int]
+sandbox/unapply.scala:34: error: could not find implicit value for parameter un: unapplybug.UnapplyAux[scalaz.Functor,scalaz.Validation[String,Int],F,A]
+ mkUnapplyAux(vis) // fails with 2.11.x
+ ^
+| | |-- [FA, F[_], A](f: FA)(implicit un: unapplybug.UnapplyAux[s... BYVALmode-EXPRmode (site solving: type F,type A: value <local UnapplyBug> in UnapplyBug)
+| | | solving for (F: ?F, A: ?A)
+| | | solving for (F: ?F, A: ?A)
+| | | \-> <error>
| | [adapt] [FA, F[_], A](f: FA)(implicit un: unapplybug.UnapplyAux[s... adapted to [FA, F[_], A](f: FA)(implicit un: unapplybug.UnapplyAux[s...
-| | \-> unapplybug.UnapplyAux[scalaz.Functor,scalaz.Validation[String,Int],scalaz.Unapply[scalaz.Functor,scalaz.Validation[String,Int]]{type M[X] = scalaz.Validation[String,X]; type A = Int}#M,Int]
+| | \-> <error>
| |-- UAAux[TC[_[_]], FA, F[_], A0]Unapply[TC, FA] { type M[x] ... BYVALmode-EXPRmode (site: object UnapplyBug)
| | |-- Unapply[TC, FA] { type M[x] = F[x]; type A = A0 } TYPEmode (site: type UAAux in UnapplyBug)
| | | |-- Unapply[TC, FA] TYPEmode (site: type UAAux in UnapplyBug)
| | | | |-- TC NOmode (site: type UAAux in UnapplyBug)
| | | | | \-> TC
| | | | |-- FA TYPEmode (site: type UAAux in UnapplyBug)
| | | | | \-> FA
| | | | \-> scalaz.Unapply[TC,FA]
| | | |-- F[x] TYPEmode (site: type M in <refinement>)
| | | | |-- x NOmode (site: type M in <refinement>)
| | | | | \-> x
| | | | \-> F[x]
| | | |-- A0 TYPEmode (site: type A in <refinement>)
| | | | \-> A0
| | | [adapt] Unapply[TC, FA] { type M[x] = F[x]; type A = A0 } is now a TypeTree(scalaz.Unapply[TC,FA]{type M[x] = F[x]; type A = A0})
| | | \-> scalaz.Unapply[TC,FA]{type M[x] = F[x]; type A = A0}
| | \-> [type UAAux] unapplybug.UnapplyBug.UAAux[TC,FA,F,A0]
| |-- def mkUAAux[FA, F[_], A] BYVALmode-EXPRmode (site: object UnapplyBug)
| | |-- UAAux[Functor, FA, F, A] TYPEmode (site: method mkUAAux in UnapplyBug)
| | | |-- Functor NOmode (site: method mkUAAux in UnapplyBug)
| | | | \-> scalaz.Functor
| | | |-- FA TYPEmode (site: method mkUAAux in UnapplyBug)
| | | | \-> FA
| | | |-- F NOmode (site: method mkUAAux in UnapplyBug)
| | | | \-> F
| | | |-- A TYPEmode (site: method mkUAAux in UnapplyBug)
| | | | \-> A
| | | \-> unapplybug.UnapplyBug.UAAux[scalaz.Functor,FA,F,A]
| | |-- FA TYPEmode (site: value f in UnapplyBug)
| | | \-> FA
| | |-- UAAux[Functor, FA, F, A] TYPEmode (site: value un in UnapplyBug)
| | | |-- Functor NOmode (site: value un in UnapplyBug)
| | | | \-> scalaz.Functor
| | | |-- FA TYPEmode (site: value un in UnapplyBug)
| | | | \-> FA
| | | |-- F NOmode (site: value un in UnapplyBug)
| | | | \-> F
| | | |-- A TYPEmode (site: value un in UnapplyBug)
| | | | \-> A
| | | \-> unapplybug.UnapplyBug.UAAux[scalaz.Functor,FA,F,A]
| | |-- UAAux[Functor, FA, F, A] TYPEmode (site: value un in UnapplyBug)
| | | |-- Functor NOmode (site: value un in UnapplyBug)
| | | | \-> scalaz.Functor
| | | \-> unapplybug.UnapplyBug.UAAux[scalaz.Functor,FA,F,A]
| | |-- UAAux[Functor, FA, F, A] TYPEmode (site: method mkUAAux in UnapplyBug)
| | | |-- Functor NOmode (site: method mkUAAux in UnapplyBug)
| | | | \-> scalaz.Functor
| | | \-> unapplybug.UnapplyBug.UAAux[scalaz.Functor,FA,F,A]
| | |-- un : pt=unapplybug.UnapplyBug.UAAux[scalaz.Functor,FA,F,A] EXPRmode (site: method mkUAAux in UnapplyBug)
| | | \-> unapplybug.UnapplyBug.UAAux[scalaz.Functor,FA,F,A]
| | \-> [def mkUAAux] [FA, F[_], A](f: FA)(implicit un: unapplybug.UnapplyBug.UAAux[scalaz.Functor,FA,F,A])unapplybug.UnapplyBug.UAAux[scalaz.Functor,FA,F,A]
| \-> [object UnapplyBug] unapplybug.UnapplyBug.type
|-- M[x]Unapply.this.M[_] BYVALmode-EXPRmode (site: <refinement>)
| |-- Unapply.this.M[_] TYPEmode (site: type M in <refinement>)
| | \-> un.M[x]
| \-> [type M] this.M[x]
|-- AUnapply.this.A BYVALmode-EXPRmode (site: <refinement>)
| \-> [type A] this.A
|-- M[x]F[_] BYVALmode-EXPRmode (site: <refinement>)
| |-- F[_] TYPEmode (site: type M in <refinement>)
| | \-> F[x]
| \-> [type M] this.M[x]
|-- AA0 BYVALmode-EXPRmode (site: <refinement>)
| \-> [type A] this.A
[[syntax trees at end of typer]] // unapply.scala
package unapplybug {
import scalaz._;
import scalaz.std.option._;
import scalaz.std.string._;
abstract trait UnapplyAux[TC[_[_] >: [_]Nothing <: [_]Any] >: [_[_]]Nothing <: [_[_]]Any, FA, F[_] >: [_]Nothing <: [_]Any, A] extends scala.AnyRef {
def TC: TC[F];
def apply(fa: FA): F[A]
};
object UnapplyAux extends scala.AnyRef {
def <init>(): unapplybug.UnapplyAux.type = {
UnapplyAux.super.<init>();
()
};
implicit def unapplyAux[TC[_[_] >: [_]Nothing <: [_]Any] >: [_[_]]Nothing <: [_[_]]Any, FA](implicit ev: scalaz.Unapply[TC,FA]): unapplybug.UnapplyAux[TC,FA,ev.M,ev.A] = {
final class $anon extends AnyRef with unapplybug.UnapplyAux[TC,FA,ev.M,ev.A] {
def <init>(): <$anon: unapplybug.UnapplyAux[TC,FA,ev.M,ev.A]> = {
$anon.super.<init>();
()
};
def TC: TC[ev.M] = ev.TC;
def apply(fa: FA): ev.M[ev.A] = ev.apply(fa)
};
new $anon()
}
};
object UnapplyBug extends scala.AnyRef {
def <init>(): unapplybug.UnapplyBug.type = {
UnapplyBug.super.<init>();
()
};
def mkUnapply[FA](f: FA)(implicit un: scalaz.Unapply[scalaz.Functor,FA]): scalaz.Unapply[scalaz.Functor,FA]{type M[x] = un.M[x]; type A = un.A} = un;
def mkUnapplyAux[FA, F[_] >: [_]Nothing <: [_]Any, A](f: FA)(implicit un: unapplybug.UnapplyAux[scalaz.Functor,FA,F,A]): unapplybug.UnapplyAux[scalaz.Functor,FA,F,A] = un;
private[this] val oi: Option[Int] = scala.Option.apply[Int](23);
<stable> <accessor> def oi: Option[Int] = UnapplyBug.this.oi;
private[this] val vis: scalaz.Validation[String,Int] = scalaz.Success.apply[Nothing, Int](13);
<stable> <accessor> def vis: scalaz.Validation[String,Int] = UnapplyBug.this.vis;
UnapplyBug.this.mkUnapply[Option[Int]](UnapplyBug.this.oi)(scalaz.this.Unapply.unapplyMA[scalaz.Functor, Option, Int](scalaz.std.option.optionInstance));
UnapplyBug.this.mkUnapply[scalaz.Validation[String,Int]](UnapplyBug.this.vis)(scalaz.this.Unapply.unapplyMAB2[scalaz.Functor, scalaz.Validation, String, Int](scalaz.this.Validation.ValidationInstances1[String]));
- UnapplyBug.this.mkUnapplyAux[Option[Int], scalaz.Unapply[scalaz.Functor,Option[Int]]{type M[X] = Option[X]; type A = Int}#M, Int](UnapplyBug.this.oi)(unapplybug.this.UnapplyAux.unapplyAux[scalaz.Functor, Option[Int]](scalaz.this.Unapply.unapplyMA[scalaz.Functor, Option, Int](scalaz.std.option.optionInstance)));
- UnapplyBug.this.mkUnapplyAux[scalaz.Validation[String,Int], scalaz.Unapply[scalaz.Functor,scalaz.Validation[String,Int]]{type M[X] = scalaz.Validation[String,X]; type A = Int}#M, Int](UnapplyBug.this.vis)(unapplybug.this.UnapplyAux.unapplyAux[scalaz.Functor, scalaz.Validation[String,Int]](scalaz.this.Unapply.unapplyMAB2[scalaz.Functor, scalaz.Validation, String, Int](scalaz.this.Validation.ValidationInstances1[String])));
+ UnapplyBug.this.mkUnapplyAux[Option[Int], Option, Int](UnapplyBug.this.oi)(unapplybug.this.UnapplyAux.unapplyAux[scalaz.Functor, Option[Int]](scalaz.this.Unapply.unapplyMA[scalaz.Functor, Option, Int](scalaz.std.option.optionInstance)));
+ UnapplyBug.this.mkUnapplyAux[scalaz.Validation[String,Int], Nothing, Nothing](UnapplyBug.this.vis)();
type UAAux[TC[_[_] >: [_]Nothing <: [_]Any] >: [_[_]]Nothing <: [_[_]]Any, FA, F[_] >: [_]Nothing <: [_]Any, A0] = scalaz.Unapply[TC,FA]{type M[x] = F[x]; type A = A0};
def mkUAAux[FA, F[_] >: [_]Nothing <: [_]Any, A](f: FA)(implicit un: unapplybug.UnapplyBug.UAAux[scalaz.Functor,FA,F,A]): unapplybug.UnapplyBug.UAAux[scalaz.Functor,FA,F,A] = un
}
}
-|-- (a: <?>)scalaz.Success[E,A] EXPRmode-FUNmode-POLYmode-TAPPmode (site: object UnapplyBug) implicits disabled
-| |-- new scalaz.Success[Nothing,Int] EXPRmode-POLYmode-QUALmode (site: object UnapplyBug) implicits disabled
-| | \-> scalaz.Success[Nothing,Int]
-| \-> (a: Int)scalaz.Success[Nothing,Int]
-warning: there were 10 feature warning(s); re-run with -feature for details
-one warning found
+one error found
Raw
unapply.scala
package unapplybug
import scalaz._
import scalaz.std.option._
import scalaz.std.string._
// From shapeless-contrib: this should go into scalaz proper, once codegen for Unapply is in place
trait UnapplyAux[TC[_[_]], FA, F[_], A] {
def TC: TC[F]
def apply(fa: FA): F[A]
}
object UnapplyAux {
implicit def unapplyAux[TC[_[_]], FA](implicit ev: Unapply[TC, FA]): UnapplyAux[TC, FA, ev.M, ev.A] = new UnapplyAux[TC, FA, ev.M, ev.A] {
def TC = ev.TC
def apply(fa: FA) = ev(fa)
}
}
object UnapplyBug {
def mkUnapply[FA](f: FA)
(implicit un: Unapply[Functor, FA]): Unapply[Functor, FA] { type M[x] = un.M[x] ; type A = un.A } = un
def mkUnapplyAux[FA, F[_], A](f: FA)
(implicit un: UnapplyAux[Functor, FA, F, A]): UnapplyAux[Functor, FA, F, A] = un
val oi = Option(23)
val vis: Validation[String, Int] = Success(13)
mkUnapply(oi)
mkUnapply(vis)
mkUnapplyAux(oi)
mkUnapplyAux(vis) // fails with 2.11.x
// I would actually prefer this variant to work if possible ...
type UAAux[TC[_[_]], FA, F[_], A0] = Unapply[TC, FA] { type M[x] = F[x] ; type A = A0 }
def mkUAAux[FA, F[_], A](f: FA)
(implicit un: UAAux[Functor, FA, F, A]): UAAux[Functor, FA, F, A] = un
//mkUAAux(oi) // fails with 2.10.x and 2.11.x
//mkUAAux(vis) // fails with 2.10.x and 2.11.x
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment