Since you’ve tagged this question with sympy, I will give such an example. From the documentation: http://docs.sympy.org/latest/modules/plotting.html. from sympy import var, plot_implicit var(‘x y’) plot_implicit(x*y**3 – y*x**3)
This can depend on a variety of factors – the operating system’s regional settings, the current user’s language and dateformat settings. By default, Windows uses US English, and the user’s settings are US English and MDY. But here are some examples to show how this can change. User is using BRITISH language settings: — works: … Read more
Scala specification says: If there are several eligible arguments which match the implicit parameter’s type, a most specific one will be chosen using the rules of static overloading resolution. https://www.scala-lang.org/files/archive/spec/2.13/07-implicits.html#implicit-parameters The relative weight of an alternative A over an alternative B is a number from 0 to 2, defined as the sum of 1 if … Read more
First, the cause of this issue: C++ Standard [over.ics.rank]/2.11 defines an order for conversion sequences. It says that a user defined conversion sequence is worse than a standard conversion sequence. What happens in your case is that the string literal undergoes a boolean-conversion (defined at 4.12. This is a standard conversion). It does not use … Read more
I eventually solved this using an ambiguity-based solution that doesn’t require prioritizing using inheritance. Here is my attempt at generalizing this. We use the type Not[A] to construct negative type classes: import scala.language.higherKinds trait Not[A] trait Monoid[_] // or import scalaz._, Scalaz._ type NotMonoid[A] = Not[Monoid[A]] trait Functor[_[_]] // or import scalaz._, Scalaz._ type NotFunctor[M[_]] … Read more
scala> val sum2 = (a: Int) => {implicit b: Int => a + b} sum2: (Int) => (Int) => Int = <function1> This will just make b an implicit value for the scope of the function body, so you can call methods that expect an implicit Int. I don’t think you can have implicit arguments … Read more
try { Intent intent = new Intent(“com.google.zxing.client.android.SCAN”); intent.putExtra(“SCAN_MODE”, “QR_CODE_MODE”); // “PRODUCT_MODE for bar codes startActivityForResult(intent, 0); } catch (Exception e) { Uri marketUri = Uri.parse(“market://details?id=com.google.zxing.client.android”); Intent marketIntent = new Intent(Intent.ACTION_VIEW,marketUri); startActivity(marketIntent); } and in onActivityResult(): @Override protected void onActivityResult(int requestCode, int resultCode, Intent data) { super.onActivityResult(requestCode, resultCode, data); if (requestCode == 0) { if (resultCode … Read more
You can debug implicits at compile time: switch on compiler flag -Xlog-implicits try to resolve implicits manually (maybe specifying type parameters as well) and see compile errors implicitly[…](…manually…) use scala.reflect println(reify { implicitly[…] }.tree) (or switch on compiler flag -Xprint:typer) in order to see how implicits are resolved use IDE functionality to show implicits using … Read more
I wrote my own answer in the form of a blog post revisiting implicits without import tax. Update: Furthermore, the comments from Martin Odersky in the above post revealed that the Scala 2.9.1’s behavior of LocalIntFoo winning over ImportedIntFoo is in fact a bug. See implicit parameter precedence again. 1) implicits visible to current invocation … Read more
Scala 2.8 added a prioritization system for implicits. It’s explained in this SIP on the new Java arrays: When comparing two different applicable alternatives of an overloaded method or of an implicit, each method gets one point for having more specific arguments, and another point for being defined in a proper subclass. An alternative “wins” … Read more