> A talented C# dev will need to know co/contravariance as well as implicits considering they also exist in C#.
True for co/contravariance. For implicits, that depends on which implicits you are talking about.
Scala has:
* implicit conversion operators (these have existed in C# for some time, under the same name)
* implicit parameters (C# doesn't have an analog to these that I can think of)
* implicit classes (C# has an analog in classes providing extension methods, though the classes themselves are distinguished by a keywords as they are in Scala; in Scala, these are essentially syntactic sugar for creating a normal class and an implicit conversion from the extended class.)
> implicit parameters (C# doesn't have an analog to these that I can think of)
C# allows default values for parameters, but it's not quite the same.
Example of C# default value for parameter:
static void Addition(int a, int b = 42)
{
Console.WriteLine(a + b);
}
Addition(4); // Prints 46
Addition(4, 5); // Prints 9
In Scala, the default (implicit) value has more complex rules.
Like C#, implicit parameters must come after non-implicit parameters (if any).
Unlike C#, the implicit value does not need to be defined in the signature. Also unlike C#, if you provide the value for one implicit parameter, you must provide the value for all implicit parameters.
using System;
public class Program
{
public class Person
{
private string _name;
private int _age;
public Person(string name, int age)
{
_name = name;
_age = age;
}
public static implicit operator int(Person p)
{
return 42;
}
}
public static void Main()
{
var person = new Person("Jim", 51);
var number = 100;
AdditionPrinter(person, number); // Prints 142
}
public static void AdditionPrinter(int a, int b)
{
Console.WriteLine(a + b);
}
}
Though implicits I feel are so much simpler than many people fear.
From a Ruby perspective: Just think of them as operating similarly to Refinements, except not completely insane because there is no global scope at compilation. You only have to worry about your own package, imports and inheritance.
Tracking down an implicit generally takes all of 10 seconds, and never more than a few minutes. Even moderately brain-bendy ones like akka.patterns.ask (where does the implicit "?" come from? "ask" is actually an implicit conversion to a class that defines it: https://github.com/akka/akka/blob/master/akka-actor/src/main...).
