Ordering<Number> k = objects.compound(objects.compound(numbers));

    // You can also arbitrarily assign a more restricted type - not an intended
    // feature, exactly, but unavoidable (I think) and harmless
    Ordering<Integer> l = objects.compound(numbers);

    // This correctly doesn't work:
    // Ordering<Object> m = numbers.compound(objects);

var unavailable = false
var healthy = true

if (process.env.SERVICE_VERSION === 'v-unavailable') {
    // make the service unavailable once in 60 seconds
    setInterval(function () {
        unavailable = !unavailable
    }, 60000);
}

if (process.env.SERVICE_VERSION === 'v-unhealthy') {
    // make the service unavailable once in 15 minutes for 15 minutes.

    private enum MemoryAvailability {
        AVAILABLE,
        UNAVAILABLE,
        INVALID_VALUE,
        ;

        String toString() {
            switch (this) {
                case AVAILABLE:
                    return "available"
                case UNAVAILABLE:
                    return "unavailable"
                case INVALID_VALUE:
                    return "an invalid value"

                      "timeout": "0s",
                      "retry_policy": {
                        "retry_on": "connect-failure,refused-stream,unavailable,cancelled,retriable-status-codes",
                        "num_retries": 2,
                        "retry_host_predicate": [
                          {

  failureThreshold: 3
```

## Cluster probe

### Cluster-writeable probe

The reply is '200 OK' if cluster has write quorum if not it returns '503 Service Unavailable'.

```
curl http://minio1:9001/minio/health/cluster
HTTP/1.1 503 Service Unavailable
Accept-Ranges: bytes
Content-Length: 0
Server: MinIO
Vary: Origin
X-Amz-Bucket-Region: us-east-1
X-Minio-Write-Quorum: 3
X-Amz-Request-Id: 16239D6AB80EBECF

                  },
                  "HostRewriteSpecifier": null,
                  "timeout": 0,
                  "retry_policy": {
                    "retry_on": "connect-failure,refused-stream,unavailable,cancelled,resource-exhausted,retriable-status-codes",
                    "num_retries": {
                      "value": 2
                    },
                    "retry_host_predicate": [
                      {

                      "timeout": "0s",
                      "retry_policy": {
                        "retry_on": "connect-failure,refused-stream,unavailable,cancelled,retriable-status-codes",
                        "num_retries": 2,
                        "retry_host_predicate": [
                          {

  {
    name = "examples-bookinfo-ratings-v-delayed"
    args = {
      service_version = "v-delayed"
    }
    source = "ratings"
  },
  {
    name = "examples-bookinfo-ratings-v-unavailable"
    args = {
      service_version = "v-unavailable"
    }
    source = "ratings"
  },
  {
    name = "examples-bookinfo-ratings-v-unhealthy"
    args = {
      service_version = "v-unhealthy"
    }

        failure.assertHasCause("""No tool chain is available to build for platform 'unavailable':
  - ${toolChain.instanceDisplayName}:
      - Don't know how to build for platform 'unavailable'.""")

        where:
        type                           | config
        "unavailable architecture"     | "architecture 'sparc'"
        "unavailable operating system" | "operatingSystem 'solaris'"

    }

    @Override
    public List<ModelPath> transform(final ModelPath unavailable) {
        Iterable<Suggestion> suggestions = Iterables.transform(availablePaths, new Function<ModelPath, Suggestion>() {
            @Override
            public Suggestion apply(ModelPath available) {
                int distance = StringUtils.getLevenshteinDistance(unavailable.toString(), available.toString());