Eric Wang's questions

:root {
    --success: #0c0;
}

button {
    border: 2px solid;
    border-radius: 10px;
    cursor: pointer;
    margin: 1em 0.5em;
    padding: 10px 15px;
    transition: transform 1s;
}

button:active {
    transform: scale(90%);
}

button.animated {
    background-color: transparent;
    overflow: hidden;
    position: relative;
    transition: color 1s, border-color 1s, transform 0.2s;
    z-index: 1;
}

button.animated:hover {
    border-color: transparent;
}

button.animated::after {
    border: 0;
    border-radius: 50%;
    content: "";
    height: 150%;
    left: -25%;
    opacity: 0;
    position: absolute;
    top: -25%;
    transform: scale(0.1);
    transform-origin: center;
    transition: all 1s;
    width: 150%;
    z-index: -1;
}

button.animated:hover::after {
    opacity: 1;
    transform: scale(1);
}

.text,
button.animated.background::after {
    background-color: white;
}

.background,
button.animated.text:hover{
    color: white;
}

button.animated.text {
    border-color: var(--muted);
}

.success.text,
button.animated.success.background:hover {
    color: var(--success);
}

.success.background,
button.animated.success.text::after {
    background-color: var(--success);
}

button.animated.success.text:hover,
button.animated.success.background {
    border-color: var(--success);
}

<button class="animated success background">Button</button>
<button class="animated success background">Longer button</button>

O botão no snippet acima tem um efeito de fundo em forma de elipse que aparece quando você passa o mouse sobre ele. Atualmente, as dimensões da elipse são proporcionais às dimensões do botão. Gostaria que a elipse fosse circular, com largura 141,4% maior que a dimensão maior do botão ou, se não for possível, a largura do botão. Como posso fazer isso?

Para entender facilmente meu problema, abaixo está uma versão simplificada de alguns exemplos de entrada.

['foo', 1, 'a', 'foo', 2, 'foo', 1, 'b', 'foo', -1, 'foo', -1, "bar", 1, "c", "bar", 2, 'baz', 1, 'd', 'baz', -1, "bar", 3, "e", "bar", 4, 'qux', 1, 'stu', 1, 'f', 'stu', -1, 'qux', -1, 'bar', -1]

(Usei "stu" porque fiquei sem nomes de espaço reservado.)

As strings são nomes de funções (mais ou menos, detalhes depois). Os números depois dos nomes de funções especificam a posição do argumento na função que se segue. Uma posição de -1 fecha a função.

Por exemplo, ['foo',1,'a','foo',2,'b','foo',-1]deve ser equivalente a foo('a', 'b').

Isso também deve funcionar quando aninhado:

['foo', 1, 'a', 'foo', 2, 'foo', 1, 'b', 'foo', -1, 'foo', -1]

deve ser equivalente a foo('a', foo('b'))e

['bar', 1, 'c', 'bar', 2, 'baz', 1, 'd', 'baz', -1, 'bar', 3, 'e', 'bar', 4, 'qux', 1, 'stu', 1, 'f', 'stu',-1, 'qux', -1, 'bar', -1]

deve ser equivalente a bar('c', baz('d'), e, qux(stu('f'))).

Minha função desejada deve retornar uma lista. Por exemplo,

['foo', 1, 'a', 'foo', 2, 'foo', 1, 'b', 'foo', -1, 'foo', -1, 'bar', 1, 'c', 'bar', -1]

deve resultar em

[['foo', 'a', ['foo', 'b']], ['bar', 'c']]

Agora que o problema está mais claro, meu problema real é um pouco diferente. Todos os elementos da lista são inteiros. Os nomes das funções não são strings, são sequências de três inteiros. Portanto, ['foo',1,'a','foo',2,'b','foo',-1]é na verdade [1, 1, 1, 1, 104, 1, 1, 1, 2, 105, 1, 1, 1, -1].

Os nomes das funções ( [1, 1, 1]no exemplo acima) agem como chaves de dicionário. O dicionário (chamado constructs) se parece com isto:

constructs = {
    1: {
        1: {
            1: lambda *chars : print(''.join(chr(char) for char in chars))
        }
    }
}

Então, finalmente, o exemplo deve resultar em algo como

[[lambda *chars : print(''.join(chr(char) for char in chars)), 104, 105]]

Todas as especificações sobre aninhamento e coisas assim ainda devem ser aplicadas. Não tenho ideia de como implementar isso de forma confiável e elegante, por favor ajude!

Desde já, obrigado.

Editar: esqueci de dizer que isso 0é sempre ignorado e pulado, e uma 0chamada de função a seguir escapará da chamada de função e fará com que ela seja tratada como um argumento. Toda essa funcionalidade é implementada até certo ponto na minha tentativa até agora , mas não funciona quando a mesma função é aninhada dentro de si mesma. Também é ineficiente e deselegante, com muitos problemas potenciais, então recorri ao Stack Overflow para obter ajuda para escrever uma melhor. Sinta-se à vontade para usá-la como ponto de partida!

Edição 2: aqui está o código da minha tentativa até agora:

constructs = {
    1: {
        1: {
            1: print,
        }
    }
}

def parse(code: list) -> list:
    if len(code) <= 1:
        return code
    result = []
    in_function = 0
    for i, token in enumerate(code):
        if in_function > 0:
            in_function -= 1
            continue
        if token == 0:
            continue
        if result and result[-1][0][3] != -1:
            if token in constructs and code[i + 1] in constructs[token] and code[i + 2] in constructs[token][code[i + 1]]:
                if i < len(code) - 4 and code[i + 4] == 0:
                    result[-1][-1].append(token)
                else:
                    if code[i + 3] == result[-1][0][3] + 1:
                        result[-1].append([])
                    result[-1][0] = code[i:i + 4]
                    in_function = 3
            else:
                result[-1][-1].append(token)
        else:
            if token in constructs and code[i + 1] in constructs[token] and code[i + 2] in constructs[token][code[i + 1]]:
                if code[i + 3] == 1:
                    result.append([code[i:i + 4], []])
                    in_function = 3
                else:
                    raise SyntaxError(f'function {code[i:i + 3]} has no previous separator {code[i + 3] - 1}')
            else:
                raise SyntaxError(f'function {code[i:i + 3]} was not recognized')
    for i, function in enumerate(result):
        result[i][0] = constructs[result[i][0][0]][result[i][0][1]][result[i][0][2]]
        for j, argument in enumerate(result[i][1:]):
            result[i][j + 1] = parse(argument)
    return result

Funciona para, parse([1, 1, 1, 1, 'Hello world', 1, 1, 1, 2, 'etc', 1, 1, 1, -1])mas não para parse([1, 1, 1, 1, 1, 1, 1, 1, 'Hello world', 1, 1, 1, -1, 1, 1, 1, 2, 'etc', 1, 1, 1, -1]).