jeffque

package jeffque;

import java.util.IdentityHashMap;
import java.util.Objects;

public class IdentityTest {

    static class SomeValue {
        int x;

jeffque

public class MustBeSingleton {

    private MustBeSingleton() {
    }

    public static MustBeSingleton getInstance() {
        return SINGLETON_LOADER.singleton;
    }

    private static class SINGLETON_LOADER {

jeffque

package jeffque.bench;

import org.openjdk.jmh.annotations.*;
import org.openjdk.jmh.infra.Blackhole;

import java.util.List;
import java.util.Random;
import java.util.concurrent.TimeUnit;
import java.util.stream.IntStream;

jeffque

Aqui uma gramática "livre de contexto" para reconhecer XMLs em geral (sem entrar na especificidade dos XSDs).

A tag de identificação por hora tá sendo ignorada, a que tem a forma <?xml ... ?>, mas seria só adicionar ela.

Para facilitar a escrita da gramática livre de contexto, estou usando aqui uma estratégia de "passagem de parâmetro". Isso facilita a indicação, por exemplo, de tags que se fecham: <p></p>, por exemplo, é derivado de TREE_NODE("p").

Para os casos de passagem de parâmetro, o "tipo" tá indicado. Por exemplo, a produção de TREE_NODE(TAG_NAME ::= IDENTIFICADOR_TAG) indica que o parâmetro TAG_NAME é feito como a produção IDENTIFICADOR_TAG.

jeffque

#!/usr/bin/env ruby
require "liquid"
require "benchmark/ips"
require "jekyll"

puts "Ruby #{RUBY_VERSION}-p#{RUBY_PATCHLEVEL}"
puts "Liquid #{Liquid::VERSION}"

module Testing
  class PostUrlAlways < Liquid::Tag

jeffque

@RestController
class SlowlorrisController {

    @GetMapping(path = "/slowlorris2", produces = "text/plain")
    StreamingResponseBody teste2() {
        return out -> {
            out.write(("COMEÇANDO!!!\n").getBytes(Charset.defaultCharset()));
            out.flush();
            for (int i = 0; i < 1000; i++) {
                out.write(("rodada %d\n".formatted(i)).getBytes(Charset.defaultCharset()));

jeffque

package jeffque;

import java.util.Scanner;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.function.Supplier;

public class Main {

jeffque

data Nat = Zero | Suc Nat
inc :: Nat -> Nat
inc x = Suc x

showNat :: Nat -> String
showNat Zero = "Zero"  
showNat (Suc v) = "Suc " ++ (show v)

type BinNat = (Nat -> Nat -> Nat)

jeffque

import java.io.IOException;
import java.io.InputStream;
import java.util.Iterator;
import java.util.function.Function;

public class ServeInputStream<T> extends InputStream {

    private final Iterator<T> iterator;
    private final Function<T, byte[]> serializer;

jeffque

data Resultado = Vazio | Valor Integer
type Mapeamento = (Integer -> Resultado)

showResultado :: Resultado -> String
showResultado Vazio = "Vazio"  
showResultado (Valor v) = "Valor " ++ (show v)

instance Show Resultado where
    show = showResultado