aesteve

public interface RouteDSL {
  
  RouteDSL param(String paramName, Handler<RoutingContext> checker)
   
  default<T> RouteDSL param(String paramName, Function<String, T> checker) {
    return param(paramName, ctx -> {
      String p = ctx.request().getParam(name);
      try {
        ctx.put(paramName, checker.apply(p));
        ctx.next();

aesteve

// It's weird it doesn't work ootb since Handler<T> is a functional java interface
// I must have missed something
fun <T> asHandler(handler: (T) -> Unit): Handler<T> =
        Handler { event -> handler(event) }

aesteve

public class InterceptorExample extends AbstractVerticle {
  
  public final static String API_PATH = "/api/v1/";
  public final static String STATIC_FILES = "/static/";
  
  // ...
  private Router router;
  
  @Override
  public void start(Future<Void> future) {

aesteve

// Let's imagin you have such a service
class TodoMongoService {
  void fetchById(String todoId, Handler<AsyncResult<Todo>> handler) {
    mongo.find(id) { res ->
      if(res.succeeded) {
        handler.handle(Future.suceededFuture(res.result))
      } else {
        handler.handle(Future.failedFuture(res.cause))
      }
    }

aesteve

java.lang.IllegalStateException: Uh oh! Event loop context executing with wrong thread! Expected null got Thread[Test worker,5,main]
	at io.vertx.core.impl.ContextImpl.lambda$wrapTask$3(ContextImpl.java:343)
	at io.vertx.core.impl.ContextImpl.executeFromIO(ContextImpl.java:240)
	at io.vertx.core.http.impl.ConnectionManager$ConnQueue.http1xConnected(ConnectionManager.java:422)
	at io.vertx.core.http.impl.ConnectionManager$ConnQueue.lambda$internalConnect$159(ConnectionManager.java:384)
	at io.vertx.core.http.impl.ConnectionManager$ConnQueue$1.lambda$connect$157(ConnectionManager.java:282)
	at io.vertx.core.net.impl.AsyncResolveBindConnectHelper.addListener(AsyncResolveBindConnectHelper.java:43)
	at io.vertx.core.http.impl.ConnectionManager$ConnQueue$1.connect(ConnectionManager.java:280)
	at io.vertx.core.http.impl.ConnectionManager$ConnQueue.internalConnect(ConnectionManager.java:395)
	at io.vertx.core.http.impl.ConnectionManager$ConnQueue.createNewConnection(ConnectionManager.java:226)

aesteve

List<Handler<RoutingContext>> handlers = /* ... */;
handlers.forEach(router.route("/a/b/")::handler); // KO : "You're attaching a handler to a route more than once" 
handlers.forEach(handler -> router.route("/a/b").handler(handler)); // works

aesteve

package main

import (
	"golang.org/x/tour/wc";
	"strings";
)

func WordCount(s string) map[string]int {
	count := make(map[string]int)
	words := strings.Fields(s)

aesteve

package main

import "golang.org/x/tour/pic"

func mult(x, y int) uint8 {
	return uint8( x * y )
}

func mid(x, y int) uint8 {
	return uint8( (x + y) / 2 )

aesteve

package com.github.vertx.node.example;

import io.vertx.core.AbstractVerticle;
import io.vertx.core.Vertx;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.Arrays;
import java.util.List;
import java.util.concurrent.TimeUnit;

aesteve

Flux is an architecture to help client-side application deal with data coming from several endpoints (API endpoints, websockets, user interaction, etc.).

The basic idea is that you're connecting to many endpoints, and when your "connectors" catch a new piece of data, they're dispatching actions (through a dispatcher).

Reducers are listening to these actions. When they catch an event they're interested in (let's say UserReducer catches an USER_DATA_UPDATED event), they "do something" with the action. Most often, they're just storing the data attached to the action somewhere, and returning their new "state". (their state represent a portion of the global store).

Components (views, basically), on the other hand, can be connected to many reducers (or to the whole store). Thanks to a pure function (connect), you'll describe what the component properties will be for a given state of the global store. Let's say your component only needs some users data and not pricing info for instance. You'll c