*       returned)
 * </ol>
 *
 * <p>Alas, {@link #reverse} is a little different. As you read backwards through a chain and
 * encounter a call to {@code reverse}, continue working backwards until a result is determined, and
 * then reverse that result.
 *
 * <h3>Additional notes</h3>
 *
 * <p>Except as noted, the orderings returned by the factory methods of this class are serializable

                }
            }
            return FileVisitResult.CONTINUE;
        }

        @Override
        public FileVisitResult visitFileFailed(final Path file, final IOException e) throws IOException {
            if (e != null) {
                logger.warn("I/O exception on {}", file, e);
            }
            return FileVisitResult.CONTINUE;
        }

        @Override

                    val zipEntry = ZipEntry(dir.relativize(file).toString())
                    processEntry(zipEntry, builder)
                    return FileVisitResult.CONTINUE
                }
            })
        }

        @Throws(IOException::class)
        private
        fun processJarFile(file: Path, builder: Trie.Builder) {

Mas, normalmente, você não precisará se preocupar com isso, é feito automaticamente, continue lendo. 🤓

///

## Casos de uso { #use-cases }

explaining why. This decision isn't always final: if you feel we have
misunderstood your intended change or otherwise think that we should reconsider
then please continue the conversation with a comment on the pull request and
we'll do our best to address any further points you raise.

Contributing as part of a class
-------------------------------

pkg crypto/tls, type Config struct, GetCertificate func(*ClientHelloInfo) (*Certificate, error)
pkg crypto/tls, type ConnectionState struct, TLSUnique []uint8

# CL 153420045 crypto/x509: continue to recognise MaxPathLen of zero as "no value"., Adam Langley <******@****.***>
pkg crypto/x509, type Certificate struct, MaxPathLenZero bool

      @Override
      public boolean cancel(boolean mayInterruptIfRunning) {
        boolean cancelled = super.cancel(mayInterruptIfRunning);
        if (cancelled) {
          // Unless it is cancelled, the delegate may continue being scheduled
          scheduledDelegate.cancel(mayInterruptIfRunning);

          /*
           * We'd love to also arrange for the inverse -- that is, to also automatically cancel this

                final Integer width = getAttributeAsInteger(attributes, "width");
                if (!fessConfig.isThumbnailHtmlImageUrl(thumbnailUrl)) {
                    continue;
                }
                if (height != null && width != null) {
                    try {
                        if (fessConfig.validateThumbnailSize(width, height)) {

                            jarStream.putNextEntry(JarEntry(entryName))
                            Files.copy(file, jarStream)
                            jarStream.closeEntry()
                            return FileVisitResult.CONTINUE
                        }
                    })
                }
            }
        }
        return sequenceOf(outputPath)
    }

...mas continue lendo abaixo para ver como superar isso.

## Tipo de Retorno e Filtragem de Dados { #return-type-and-data-filtering }

Vamos continuar do exemplo anterior. Queríamos **anotar a função com um tipo**, mas queríamos poder retornar da função algo que realmente incluísse **mais dados**.