rssh

trait LoggedAsyncInput[T]
{
    
    override def  onReceive(acceptor: T => ()) =
         super.onReceive(x => { println(s“received:${x}”)
                                                 acceptor(x) })

}

rssh

trait AsyncInput[T]
{
   def onReceive(acceptor: T=>()): Unit

   def read: Future[T] = {
       Promise p = Promise[T]()
       onReceive(p.complete(_))
       p.future
   }

rssh

interface AsyncInput<T>
{
   void  onReceive(Acceptor<T> acceptor)

   default void read(): Future<T>  {
      final CompletableFuture<T> promise = new CompletableFuture<>();
      onReceive( x -> promise.complete(x) );
      return promise;
   }
   

rssh

 var (maxFirstLen, maxSecondLen) = (0,0)
  list.foreach{
      x => maxFirstLen = max(maxFirstLen, x.firstName.length)
              maxSecondLen = max(maxSecondLen, x.secondName.lenght)
}

rssh

  list.sort((x,y) => {
     val cmp = x.lastName.compareTo(y.lastName)
     if (cmp!=0) cmp else x.firstName.compareTo(y.lastName)
 }

rssh

   list.sort((x,y)-> { 
      int cmp = x.lastName.compareTo(y.lastName);
      return cmp!=0 ? cmp : x.firstName.compareTo(y.firstName)
  }

rssh

public  class  Person extends DTOBase
{
  public String  firstName;
  public String  lastName;
}

rssh

public class Person
{
  private  String firstName;
  private  String lastName;
  
  String getFirstName() { return firstName; }
  void setFirstName(String firstName) { this.firstName = firstName; }
  
  String getLastName() { return  lastName; }
  void setLastName(String lastName) { this.lastName = lastName; }

rssh

case class Person(firstName:String, lastName:String)

rssh

package x

import akka.actor._
import scala.concurrent._
import scala.concurrent.duration._
import ExecutionContext.Implicits.global

object X
{