// Type could be something else
Callable<String> callHello = new Callable<String>() {
    @Override
    public String call() throws Exception {
        // Could be a db query, api call...
        return "Hello";
    }
};

Callable<String> callWorld = new Callable<String>() {
    @Override
    public String call() throws Exception {
        return "World";
    }
};

Observable.just(callHello, callWorld)
        .map(new Function<Callable<String>, String>() {
            @Override
            public String apply(Callable<String> callable) throws Exception {
                return callable.call();
            }
        })
        .subscribe(new Consumer<String>() {
            @Override
            public void accept(String x) throws Exception {
                System.out.println(x);
            }
        });

interface ModelRepository<T extends Model> {
    List<T> listModels();
}

class UserRepository implements ModelRepository<User> {

    @Override
    public List<User> listModels() {
        return userDAO.list();
    }
}

class EventRepository implements ModelRepository<Event> {

    @Override
    public List<Event> listModels() {
        return eventDAO.list();
    }
}

Observable.just(userRepository, eventRepository)
        .map(ModelRepository::listModels)
        .subscribe(listOfModels -> {/* do something with List<Model> */});

Observable.fromCallable(() -> blockingGetUserFromRemote())
            .flatMap(user -> Observable.fromCallable(() -> blockingSaveUserToLocal(user)))
            .subscribe(saveResult -> { /* Do something with save result */ });