class Stack[+A] {
  def push[B >: A](elem: B): Stack[B] = new Stack[B] {
    override def top: B = elem
    override def pop: Stack[B] = Stack.this
    override def toString = s"$elem ${Stack.this}"
  }
  def top: A = sys.error("no element on stack")
  def pop: Stack[A] = sys.error("no element on stack")
  override def toString = ""
}
object VariancesTest extends App {
  println(Stack().push("hello").push(Object()).push(7))
}

enum IndentWidth:
  case Run(ch: Char, n: Int)
  case Conc(l: IndentWidth, r: Run)
  def <= (that: IndentWidth): Boolean = this match
    case Run(ch1, n1) =>
      that match
        case Run(ch2, n2) => n1 <= n2 && (ch1 == ch2 || n1 == 0)
        case Conc(l, r)   => this <= l
    case Conc(l1, r1) =>
      that match
        case Conc(l2, r2) => l1 == l2 && r1 <= r2
        case _            => false
  def < (that: IndentWidth): Boolean =
    this <= that && !(that <= this)
  override def toString: String = this match
    case Run(ch, n) =>
      val kind = ch match
        case ' '  => "space"
        case '\t' => "tab"
        case _    => s"'$ch'-character"
      val suffix = if n == 1 then "" else "s"
      s"$n $kind$suffix"
    case Conc(l, r) =>
      s"$l, $r"
object IndentWidth:
  private inline val MaxCached = 40
  private val spaces = IArray.tabulate(MaxCached + 1)(new Run(' ', _))
  private val tabs = IArray.tabulate(MaxCached + 1)(new Run('\t', _))
  def Run(ch: Char, n: Int): Run =
    if n <= MaxCached && ch == ' ' then
      spaces(n)
    else if n <= MaxCached && ch == '\t' then
      tabs(n)
    else
      new Run(ch, n)
  end Run
  val Zero = Run(' ', 0)
end IndentWidth

printf("%10.2f", x);

cout << setw(10) << setprecision(2) << fixed << x;

java.text.NumberFormat formatter = java.text.NumberFormat.getNumberInstance();
formatter.setMinimumFractionDigits(2);
formatter.setMaximumFractionDigits(2);
String s = formatter.format(x);
for (int i = s.length(); i < 10; i++) System.out.print(' ');
System.out.print(s);

System.out.printf("%10.2f", x);

printf("%10.2f", x)

println(f"$x%10.2f")

case class Person(firstName: String, lastName: String)
val mr = Person("Bob", "Dobbelina")
val miss = Person("Roberta", "MacSweeney")
val mrs = miss.copy(lastName = mr.lastName)

public class Person implements Serializable {
    private final String firstName;
    private final String lastName;
    public Person(String firstName, String lastName) {
        this.firstName = firstName;
        this.lastName = lastName;
    }
    public String getFirstName() {
        return firstName;
    }
    public String getLastName() {
        return lastName;
    }
    public Person withFirstName(String firstName) {
        return new Person(firstName, lastName);
    }
    public Person withLastName(String lastName) {
        return new Person(firstName, lastName);
    }
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }
        if (o == null || getClass() != o.getClass()) {
            return false;
        }
        Person person = (Person) o;
        if (firstName != null ? !firstName.equals(person.firstName) : person.firstName != null) {
            return false;
        }
        if (lastName != null ? !lastName.equals(person.lastName) : person.lastName != null) {
            return false;
        }
        return true;
    }
    public int hashCode() {
        int result = firstName != null ? firstName.hashCode() : 0;
        result = 31 * result + (lastName != null ? lastName.hashCode() : 0);
        return result;
    }
    public String toString() {
        return "Person(" + firstName + "," + lastName + ")";
    }
}
Person mr = new Person("Bob", "Dobbelina");
Person miss = new Person("Roberta", "MacSweeney");
Person mrs = miss.withLastName(mr.getLastName());

object Main extends App {
  val keywords = List("Apple", "Ananas", "Mango", "Banana", "Beer")
  val result = keywords.sorted.groupBy(_.head)
  println(result)
}

import java.util.*;
class Main {
  public static void main(String[] args) {
    List<String> keywords = Arrays.asList("Apple", "Ananas", "Mango", "Banana", "Beer");
    Map<Character, List<String>> result = keywords.stream().sorted().collect(Collectors.groupingBy(it -> it.charAt(0)));
    System.out.println(result);
  }
}

import java.util.*;
class Main {
  public static void main(String[] args) {
    List<String> keywords = Arrays.asList("Apple", "Ananas", "Mango", "Banana", "Beer");
    Map<Character, List<String>> result = new HashMap<Character, List<String>>();
    for(String k : keywords) {
      char firstChar = k.charAt(0);
      if(!result.containsKey(firstChar)) {
        result.put(firstChar, new  ArrayList<String>());
      }
      result.get(firstChar).add(k);
    }
    for(List<String> list : result.values()) {
      Collections.sort(list);
    }
    System.out.println(result);
  }
}

import scala.sys.process._
import scala.io.Source
import scala.collection.JavaConversions._
import java.nio.charset.Charset
import java.nio.file._
import scala.collection.mutable.ArrayBuffer
import java.nio.file.attribute.BasicFileAttributes
  val pretend = true // set to false to run in real mode
  val commit = "765163c6cb31c9df1ad3dc86c6ca6053cf25deeb"
  val srcDir = Paths.get("C:/Dev/source/ant-project")
  val destDir = Paths.get("C:/Dev/source/mvn-project")
  val workDir = Paths.get("work")
  val nameFile = workDir.resolve("gitlog.txt")
  val changesetFile = workDir.resolve("changeset.txt")
  val unwiseCommandFile = workDir.resolve("unwise.cmd")
  val wisesetFile = workDir.resolve("wiseset.txt")
  val wiseCommandFile = workDir.resolve("wise.cmd")
  val pretendOp = if (pretend) "-n " else ""
/**
  * Script to prepare modified files, placing them to the old place,
  * To be run before the merge
  */
  def unwiseChanges = {
    Files.createDirectories(workDir)
    val logcmd =
      s"""git log $commit..HEAD --pretty="format:" --name-only"""
    val exitVal = Process(logcmd, srcDir.toFile) #> nameFile.toFile !
    if (exitVal != 0) exit(exitVal)
    val lines = Source
      .fromFile(nameFile.toFile)
      .getLines
      .filter(!_.isEmpty)
    val files = lines
      .map(Paths.get(_))
      .toList
      .sorted
      .distinct
    val changeset = files.map { src =>
      src -> target(src)
    }
    Files.write(
      changesetFile,
      changeset.map(p => s"${p._1} -> ${p._2}"),
      Charset.defaultCharset
    )
    val adds = changeset
      .filter(p => Files.exists(srcDir.resolve(p._1))
              && Files.notExists(destDir.resolve(p._2)))
    val moves = changeset
      .filter(p => p._1 != p._2 && Files.exists(srcDir.resolve(p._1))
              && Files.exists(destDir.resolve(p._2)))
    val dels = changeset
      .filter(p => p._1 != p._2
              && Files.notExists(srcDir.resolve(p._1))
              && Files.exists(destDir.resolve(p._2)))
    val cmds =
      moves.map(p => s"""git mv -v ${pretendOp}"${p._2}" "${p._1}"""") ++
      dels.map(p => s"""git rm ${pretendOp}"${p._2}"""")
    println(adds.map(p => s"# add: ${p._1} -> ${p._2}").mkString("\n"))
    moves.foreach { p =>
      Files.createDirectories(destDir.resolve(p._1.getParent))
    }
    Files.write(unwiseCommandFile, cmds, Charset.defaultCharset)
    val results = cmds.map { cmd =>
      Process(cmd, destDir.toFile)!
    }
    println(s"""Successfully processed ${results.count(0 == _)} files,
               | failed: ${results.count(0 != _)} files""".stripMargin)
  }
  unwiseChanges