Observations

  if (message inscanceof CancellationMessage) { application.cancelnahren(); }
  else if (message instanceof EncouragementMessage) { galera.trabalha(); }
// etc

  class Message {
    enum type {
      CANCEL,
      ENCOURAGE,
      DGAF} myType;
    ....
  }
...
  switch(message.type()) {
    case CANCEL: ...
    case ENCOURAGE: ...
    case DGAF: ...
  }

  class mc = message.getClass();
  if (mc.equals(CancelMessage.class)) { ... }
  else if (....

  message match {
    case CancelMessage(timeout: TimeInSeconds) => app.cancelato(timeout)
    case EncourageMessage(text: String) => galera.listen(text); galera.trabalha
    ...
  }

  reset {
    switch {
      case STILL_READING: ...; break
      case GOT_RESULT: ...; return
      case ERROR: ...; return
    }
    shift(k) {
      do {
        var resp = XHR.doPost(myStuff)
        k(resp)
      }
    }
  }

    public final static Pattern CRLF = Pattern.compile("\n\r|\r\n|\n");
    
    /**
     * Iterates over the lines of input.
     * 
     * Usage example:
     *    for (String s : iterate(new FileReader("system.properties")) {
     *       ...
     *    }
     *    
     * @param in
     * @return an iterable
     */
    public static Iterable iterate(final Readable in) {
        return iterate(in, CRLF);
    }
    
    /**
     * Iterates over the lines of input.
     * 
     * Usage example:
     *    for (String s : iterate(new FileReader("system.properties", "\n")) {
     *       ...
     *    }
     * 
     * @param in
     * @param delimiter
     * @return
     */
    public static Iterable iterate(final Readable in, String delimiter) {
        return iterate(in, Pattern.compile(delimiter));
    }
    
    /**
     * Iterates over the lines of input.
     * 
     * Usage example:
     *    for (String s : iterate(new FileReader("system.properties", Readables.CRLF)) {
     *       ...
     *    }
     * 
     * @param in
     * @param delimiter
     * @return
     */
    public static Iterable iterate(final Readable in, final Pattern delimiter) {
        return new Iterable() {

            @Override
            public Iterator iterator() {
                return new Scanner(in).useDelimiter(delimiter);
            }};
    }

    /**
     * Iterates over a LineNumberReader
     * Usage:
     *   LineNumberReader r = new LineNumberReader(new InputStreamReader(new FileInputStream("system.properties")));
     *   for (String line : r) {
     *       ...
     *   }
     * @param in the source
     * @return an iterable that scans over the lines of the source
     * @throws IOException when it cannot read the first line
     * @throws RuntimeException when it cannot read further down the stream
     */

    public static Iterable<String> iterate(final LineNumberReader in) throws IOException {
        final String first = in.readLine();
        return new Iterable<String>() {

            @Override
            public Iterator iterator() {
                return new Iterator() {
                    String current = first;

                    @Override
                    public boolean hasNext() {
                        return current != null;
                    }

                    @Override
                    public String next() {
                        if (!hasNext()) {
                            throw new NoSuchElementException();
                        }
                        try {
                            return current;
                        } finally {
                            try {
                                current = in.readLine();
                            } catch (IOException e) {
                                throw new RuntimeException(e);
                            }
                        }
                    }

                    @Override
                    public void remove() {
                        throw new UnsupportedOperationException();
                    }
                    
                };
            }};
    }

    @Test
    public void testPutAll() throws Exception {
        File folder = new File(ROOT, "Shakespeare");
        folder.mkdirs();
        Folder f = new Folder(folder);
        Map<String, ByteArray> m = Maps.newHashMap();
        m.put("sonnet1.1", new ByteArray("From fairest creatures we desire increase"));
        m.put("sonnet1.2", new ByteArray("That thereby beauty's rose might never die"));
        m.put("sonnet1.3", new ByteArray("But as the riper should by time decease"));
        m.put("sonnet1.4", new ByteArray("His tender heirs bear his memory"));
        f.putAll(m);
        assertEquals(m, f);
    }

/**
   * @return the number of families in familyMap
   */
  public int numFamilies() {
    if(hasFamilies()) {
      return this.familyMap.size();
    }
    return 0;
  }

  /**
   * @return true if familyMap is non empty, false otherwise
   */
  public boolean hasFamilies() {
    return !this.familyMap.isEmpty();
  }

public class TimeStats extends Stats {
	private static final double MS = 0.000001;
	private long startedNano;

	public void start() {
		startedNano = System.nanoTime();
	}
	
	public void finish() {
		add(System.nanoTime() - startedNano);
	}

	public String millis(double nano) {
		return MS * nano + "ms";
	}
	
	public String toString() {
		return "min: " + millis(min) + ", max:" + millis(max) + ", avg:" + millis(average());
	}
}