Como gerar seqüências aleatórias que correspondem a um Regex em Julia?

Perguntas relacionadas:

• Sequência aleatória que corresponde a uma regexp
• Como gerar uma sequência alfanumérica aleatória em julia?

A questão é bastante simples. Encontrei inúmeras alternativas para outros idiomas, mas não em Julia:

Gerador de texto aleatório baseado em regex

Também Random.randstringnão toma Regexcomo argumento.

Deve ser possível usar o Automa.jl para criar um DFA e percorrê-lo aleatoriamente. O Automa usa uma sintaxe mais simples que o PCRE, portanto, o idioma que você pode descrever deve ser regular.

Eu juntei rapidamente o seguinte, com base principalmente no código dot.jl:

julia> function rand_re(machine::Automa.Machine)
           out = IOBuffer()
           node = machine.start

           while true
               if node.state ∈ machine.final_states
                   (rand() ≤ 1 / (length(node.edges) + 1)) && break
               end

               edge, node = rand(node.edges)
               label = rand(collect(edge.labels))
               print(out, Char(label))
           end

           return String(take!(out))
       end
rand_re (generic function with 1 method)

julia> rand_re(Automa.compile(re"a[0-9][ab]+"))
"a6bbb"

julia> rand_re(Automa.compile(re"a[0-9][ab]+"))
"a9b"

julia> rand_re(Automa.compile(re"a[0-9][ab]+"))
"a3aa"

julia> rand_re(Automa.compile(re"a[0-9][ab]+"))
"a1a"

julia> rand_re(Automa.compile(re"a[0-9][ab]+"))
"a5ba"

A ressalva é que o Automa usa conjuntos codificados em bytes para etiquetas de borda, portanto, mais cuidados devem ser tomados onde eu apenas escrevo Char(label).

Como os estados finais ainda podem ter arestas de saída, optei por tratar a parada e cada aresta com probabilidade uniforme. Eu acho que isso provavelmente terá o efeito de que termos potencialmente infinitos serão muito curtos ou muito longos; google "amostradores Boltzmann" para saber como resolver isso (não confunda com amostragem de uma distribuição Boltzmann!), mas a solução está matematicamente envolvida.

Julia possui PCRE , o que significa que suas expressões regulares são muito mais poderosas que as verdadeiras expressões regulares. E estão de fato completos. Eu suspeito que há um monte de ciência da computação teórica interessante em torno disso. Suspeito que sua tarefa para PCRE possa ser provada impossível por causa do problema de interrupção . Ainda assim, o que podemos fazer é tentar um monte de strings aleatórios e jogar fora aqueles que não combinam. E para regex simples que percorre um longo caminho. Não é garantido que você responda.

Se alguém quiser regex mais rigoroso, como os cobertos pelo Automa.jl , provavelmente há algo melhor a ser feito, pois você pode percorrer a máquina de estado resolvendo-a 1 bit por vez. Espero que alguém que conheça o Automa.jl possa postar sua própria resposta.

Código

using Random: randstring

function rand_matching(regex; max_len=2^16, max_attempts=1000)
    for _ in max_attempts
        str  = randstring(max_len)
        m = match(regex, str)
        if m != nothing
            # rather than return whole string, 
            # just return the shortest bit that matches
            return m.match
        end
    end
    error("Could not find any string that matches regex")
end

demo:

julia> @time rand_matching(r"\d\d")
  0.013517 seconds (34.34 k allocations: 1.998 MiB)
"38"

julia> @time rand_matching(r"\d\d")
  0.001497 seconds (11 allocations: 128.656 KiB)
"44"

julia> @time rand_matching(r"a\d\d")
  0.000670 seconds (11 allocations: 128.656 KiB)
"a19"

julia> @time rand_matching(r"a\d\d")
  0.000775 seconds (11 allocations: 128.656 KiB)
"a83"

julia> @time rand_matching(r"a\d\db")
  0.000670 seconds (11 allocations: 128.656 KiB)
"a44b"