implicit

问题 I am trying to create a typeclass Default that supplies the default value for a given type. Here is what I have come up with so far: trait Default[A] { def value: A } object Default { def withValue[A](a: A) = new Default[A] { def value = a } def default[A : Default]: A = implicitly[Default[A]].value implicit val forBoolean = withValue(false) implicit def forNumeric[A : Numeric] = withValue(implicitly[Numeric[A]].zero) implicit val forChar = withValue(' ') implicit val forString = withValue(""

问题 I never liked implicit operators (prefer extension methods) because it is hard to see visually when that cast/conversion happens in the code. Imagine if you have example like below: public static implicit operator Deal(string dealAsXml) { //convert the xml into Deal object } Above implicit operator helps you to cast/convert deal in Xml format into Deal Object. Usually when you right click on a method, you can use "Find Usages" (or Alt+F7) on it, which is quite helpful, is there anything

问题 I'm using implicit def to build a recursive HList type, to match several kind of higher kinded types of HList . I'm heavily inspired by this post. This code is working perfectly : sealed trait HList { type Plus[L <: HList] <: HList } class HNil extends HList { type Plus[L <: HList] = L def ::[T](v: T) = HCons(v, this) } case class Appender[L1 <: HList, L2 <: HList, R <: HList](fn: (L1, L2) => R) { def apply(l1: L1, l2: L2) = fn(l1, l2) } object HNil extends HNil object HList { def ++[L1 <:

问题 Suppose I want to wrap code that can throw exceptions with a try-catch block that logs the exception and continues. Something like: loggingExceptions { // something dangerous } Ideally, I would like to use for logging the Logger defined on the calling object, if any (and if none, get a compile-time error). I'd love to define something like this: def loggingExceptions[L <: { def logger: Logger }](work: => Unit)(implicit objectWithLogger: L): Unit = { try { work } catch { case t: Exception =>

问题 Scala functions has following methods for chaining: fn1.andThen(fn2) fn1.compose(fn2) But how can be written this case: I have function cleanUp() which has to be called always as last step. And I have a bunch of other functions, like that: class Helper { private[this] val umsHelper = new UmsHelper() private[this] val user = umsHelper.createUser() def cleanUp = ... // delete user/ and other entities def prepareModel(model: TestModel) = { // create model on behalf of the user } def commitModel(

问题 I'm reading a tutorial for C++ but it didn't actually give me a difference (besides syntax) between the two. Here is a quote from the tutorial. You can also assign values to your variables upon declaration. When we assign values to a variable using the assignment operator (equals sign), it’s called an explicit assignment: int nValue = 5; // explicit assignment You can also assign values to variables using an implicit assignment: int nValue(5); // implicit assignment Even though implicit

问题 There seems to be a lot of enthusiasm among Scala bloggers lately for the type classes pattern, in which a simple class has functionality added to it by an additional class conforming to some trait or pattern. As a vastly oversimplified example, the simple class: case class Wotsit (value: Int) can be adapted to the Foo trait: trait Foo[T] { def write (t: T): Unit } with the help of this type class: implicit object WotsitIsFoo extends Foo[Wotsit] { def write (wotsit: Wotsit) = println(wotsit

问题 Given is the equation: Y^2 = X^3 + 2*X - 3*X*Y Assuming the plotted sketch is correct. Y^2 = X^3 + 2*X - 3*X*Y Hint: Y^2 + X^2 =1 ==> Y= sqrt( 1 - X^2 ) The X values are known. How can I find the corresponding Y values for X values? E.g. for known X-Values, I expect something like below listed Y-Values (see the plotted sketch): X= 1 ; Y=0.79 X=2 ; Y=1.58 X=3 ; Y=2.79 X=4 ; Y=4.39 X=5 ; Y=6.33 X=6 ; Y=8.57 X=7 ; Y=11.12 X=8 ; Y=13.92 X=9 ; Y=16.98 X=10 ; Y= 20.29 E.g. I will try to find Y for

问题 I'm looking to open a calculator from within my Activity. Here's my code right now and it works: Intent i = new Intent(); i.setClassName("com.android.calculator2", "com.android.calculator2.Calculator"); I would like to make this an implicit call because I don't know what calculator the use would like to use and I would like to leave the option open to receive a value from the calculator, which the android one apparently doesn't do. I haven't been able to find a good example of how to

问题 Consider the following code, derived from the metascala project: object Units { case class Quantity[M <: MInt, T: Numeric](value: T) { type This = Quantity[M, T] def *[M2 <: MInt](m: Quantity[M2, T]) = Quantity[M + M2, T](numeric[T].times(value, m.value)) def /[M2 <: MInt](m: Quantity[M2, T]) = Quantity[M - M2, T](numeric[T].div(value, m.value)) def apply(v: T) = Quantity[M, T](numeric[T].times(v, value)) } implicit def measure[T: Numeric](v: T) = Quantity[_0, T](v) implicit def