@Override
    @SuppressWarnings({ "rawtypes", "unchecked" })
    public String format() {
        final List<String[]> strings = new ArrayList<>();
        Class<?>[] types0 = null;
        
        for (T t : this) {
            Object[] array = t instanceof Tuple
                           ? ((Tuple) t).toArray()
                           : new Object[] { t };
            
            if (types0 == null) 
                types0 = new Class[array.length];
            
            for (int i = 0; i < array.length; i++)
                if (types0[i] == null && array[i] != null)
                    types0[i] = array[i].getClass();
            
            strings.add(Seq
                .of(array)
                .map(o -> 
                     o instanceof Optional
                   ? ((Optional) o).map(Objects::toString).orElse("{empty}")
                   : Objects.toString(o))
                .toArray(String[]::new));
        }
        
        if (strings.isEmpty())
            return "(empty seq)";
        
        final Class<?>[] types = types0;
        final int length = types.length;
        final int[] maxLengths = new int[length];
        for (int s = 0; s < strings.size(); s++)
            for (int l = 0; l < length; l++)
                maxLengths[l] = Math.max(2, Math.max(maxLengths[l], strings.get(s)[l].length()));
        
        Function<String, String>[] pad = IntStream
            .range(0, length)
            .mapToObj(i -> (Function<String, String>) string -> {
                boolean number = Number.class.isAssignableFrom(types[i]);
                return Seq.seq(Collections.nCopies(maxLengths[i] - string.length(), " ")).toString("", number ? "" : string, number ? string : "");
            })
            .toArray(Function[]::new);
                
        StringBuilder separator = new StringBuilder("+-");
        for (int l = 0; l < length; l++) {
            if (l > 0)
                separator.append("-+-");
            
            for (int p = 0; p < maxLengths[l]; p++)
                separator.append('-');
        }
        separator.append("-+\n");
        
        StringBuilder result = new StringBuilder(separator).append("| ");
        for (int l = 0; l < length; l++) {
            String n = "v" + (l + 1);
            
            if (l > 0)
                result.append(" | ");
            
            result.append(pad[l].apply(n));
        }
        result.append(" |\n").append(separator);
        for (int s = 0; s < strings.size(); s++) {
            result.append("| ");
                    
            for (int l = 0; l < length; l++) {
                String string = strings.get(s)[l];
                
                if (l > 0)
                    result.append(" | ");
                
                result.append(pad[l].apply(string));
            }
            
            result.append(" |\n");
        }
        
        return result.append(separator).toString();
    }
Always returns false. Seq streams are always sequential and, as such,
doesn't support parallelization.

@return false
@see <a href="https://github.com/jOOQ/jOOL/issues/130">jOOL Issue #130</a>
jOOL/src/main/java/org/jooq/lambda/SeqImpl.java