I have the following:
object T { abstract class First { def doSomething= (s:String) => Unit } class Second extends First { override def doSomething = { (s:String) => () } } def main(args: Array[String]): Unit = { new Second().doSomething } } but this fails to compile with the error:
Error:(8, 21) type mismatch; found : Unit required: Unit.type (s:String) => () Why isn't the override from class Second valid? How could I make it work?
The problem is that (s:String) => Unit is returning Unit.type - instead change it to (s:String) => () (or to a method if you didn't mean to be returning Function1[String, Unit] from your method.)
To put it another way:
def doSomething = (s:String) => Unit is really:
def doSomething: (String) => Unit.type = // A function that takes a string and returns the companion type of Unit (s: String) => Unit While what you probably wanted was:
def doSomething: (String) => Unit = // A function that takes a string and returns Unit (s: String) => () Or maybe:
def doSomething(s: String): Unit // An abstract method that takes a string and returns nothing. 
Unit companion doesn't justify the confusion. I don't actually know why the unit value syntax () is not an alias for it. Does SIP-23 make it easier to affirm that Unit.type and ().type are the same thing in that case?
T1 => T2 in type position with (v: T1) => r: T2 in value position I think String => () vs (s: String) => () // Is really ().type would be more confusing. (Unless I am mis-understanding what you mean).def f(): () = println(), tongue in cheek. (It doesn't compile.) For now, just eliminating Unit object would avoid incidental complexity; and I wanted to express sympathy for OP.
(s:String) => Unit returns Unit.type ie it returns the type rather than a value of that type. You want to do (s:String) => (), which will return a value, whose type is Unit.
Unit.type is the unit companion Unit.' trait Processor0 { def process = (x:String) => () } case class Processor2() extends Processor0 { override def process = (x:String) => println("Processor2 x :" + x) } case class Processor3() extends Processor0 { override def process = (x:String) => println("Processor3 x :" + x) } object DemoProc2 { def main( args : Array[String]):Unit ={ val s:String = "yes" val myFuncs: Map[String,(String) => () ]= Map( //Error 1. '=>' expected but ']' found. 2.identifier expected but ';' found. "string2" -> (() => ProcessorTwo().process(s)), "string3" -> (() => ProcessorThree().process(s)) ) myFuncs.values.foreach(v => v()); } } ' 
