implicit

I have read the answer to my question about scala.math.Integral but I do not understand what happens when Integral[T] is passed as an implicit parameter. (I think I understand the implicit parameters concept in general). Let's consider this function import scala.math._ def foo[T](t: T)(implicit integral: Integral[T]) { println(integral) } Now I call foo in REPL: scala> foo(0) scala.math.Numeric$IntIsIntegral$@581ea2 scala> foo(0L) scala.math.Numeric$LongIsIntegral$@17fe89 How does the integral argument become scala.math.Numeric$IntIsIntegral and scala.math.Numeric$LongIsIntegral ? The

I know VB.Net does not allow implicit interface implementation like C#. And thus code like the following has no direct VB.Net correlation: public interface IBackgroundWorkerAdapter { bool IsBusy { get; set; } bool WorkerReportsProgress { get; set; } bool WorkerSupportsCancellation { get; set; } event DoWorkEventHandler DoWork; event ProgressChangedEventHandler ProgressChanged; event RunWorkerCompletedEventHandler RunWorkerCompleted; void RunWorkerAsync(); void CancelAsync(); void ReportProgress(int progressPercent); void ReportProgress(int progressPercent, object userState); } public class

I try to implement some number type and I hit the issue that mynum * 1 works, but not 1 * mynum I tried to define an implicit conversion like this case class Num(v: Int) { def * (o: Int) = new Num(v*o) } implicit def int2Num(v: Int) = Num(v) but it doesn't seem work, because I always get the following error: scala> 1 * new Num(2) <console>:14: error: overloaded method value * with alternatives: (x: Double)Double <and> (x: Float)Float <and> (x: Long)Long <and> (x: Int)Int <and> (x: Char)Int <and> (x: Short)Int <and> (x: Byte)Int cannot be applied to (Num) 1 * new Num(2) ^ On the other hand 1 *

Why when i use this: int a = 1; methodWithParamString(a + ""); a is cast to String, bu i can't use toString() on integer? int a = 1; methodWithParamString(a.toString()); Doesn't this: a+"" works like: a.toString() + "" ? No, it works like String.valueOf( a ) + "" , which in turn behaves like new StringBuilder( String.valueOf( a ) ).append( "" ).toString() . The important thing to know is that it's all just done by the compiler, in other words it's syntactic sugar. This is why adding strings together in a loop isn't a good idea for example. (Although modern VMs might have some mechanism to

When my program consists of two files: main.c #include <stdio.h> int main(void) { printf("%lf\n",f()); return 0; } func.c double f(int a) { return 1; } compiler do not show any errors. When my program consists of only one file: main.c #include <stdio.h> int main(void) { printf("%lf\n",f()); return 0; } double f(int a) { return 1; } Visual C++ 2008 compiler show the following error: Error 2 error C2371: 'f' : redefinition; different basic types d:\temp\projects\function1\function1\1.c 8 function1 Can anybody explain this strange behavior? Both the programs are wrong. Without a prototype in

i'm wondering why linkers can not do their job simply by consulting the information in the actual .dll files that got the actual implementation code ? i mean why linkers still need .lib files to do implicit linking ? are not the export and relative address tables enough for such linking ? is there anyway by which one can do implicit linking using only the .dll without the .lib stub/proxy files ? i thought the windows executable loader would simply do LoadLibrary/LoadLibraryEx calls on behalf of the program (hence the name implicit linking) which is the main difference to explicit linking. if

scala> class A(implicit a: Int); defined class A scala> class B()(implicit a: Int); defined class B scala> new A()(1) res1: A = A@159d450 scala> new B()(1) res2: B = B@171f735 scala> new A(1) <console>:7: error: too many arguments for constructor A: ()(implicit a: Int)A new A(1) Why does Scalac insert an empty parameter list before the implicit parameter list provided in the class declaration? This seems to be a feature, not a bug, judging by the commentary in the scalac sources : // convert (implicit ... ) to ()(implicit ... ) if its the only parameter section I'm curious to know why this is

I've been wondering whether transparent implicit conversions are really such a good idea and whether it might actually be better to use implicits more, um, explicitly . For example, suppose I have a method which accepts a Date as a parameter and I have an implicit conversion which turns a String into a Date : implicit def str2date(s: String) : Date = new SimpleDateFormat("yyyyMMdd").parse(s) private def foo(d: Date) Then obviously I can call this with a transparent implicit conversion: foo("20090910") Would it be better to make the fact that I am converting the string into a date more explicit