Estou planejando escrever um GolfScript aprimorado para programas ainda mais curtos que podem fazer mais coisas. Isto não é um desafio; é um pedido de feedback e dicas sobre o que devo fazer. (ver tags)

^{Não tenho certeza se esse deve ser o Wiki da comunidade. Se você acha, basta sinalizar para um moderador convertê-lo :)}

Essa linguagem será muito semelhante ao GolfScript. Ainda está escrito em Ruby. No entanto, há algumas diferenças:

• Usando `como um delimitador de string, por ser um caractere incomum, será necessário menos escape. (Outro personagem pode substituir sua função, como #(mais sobre isso mais tarde)). \`para escapar de um backtick, \\para escapar de uma barra invertida e não há outras seqüências de escape. Se você precisar de uma nova linha, basta inserir uma nova linha literal na string.
• Usando Ruby's Rationalpara o ponto flutuante de precisão arbitrária, uma das principais falhas do GolfScript.
• A capacidade de converter tipos para outros tipos. Por exemplo, você pode converter um bloco em uma string.
• Expressões regulares. Provavelmente criado com "...". Os operadores também serão sobrecarregados. Por exemplo "\W"~{`Invalid: non-word character`}{`OK`}if,. Será executado automaticamente quando pressionado de uma variável, como blocos.
• Objetos File e Date, para fazer mais coisas impossíveis no GolfScript. Eles não terão literais, mas terão funções para inicializá-los, como `file.txt`fl(o nome da função de criação de arquivo pode mudar).
• Hashes talvez, mas não tenho certeza disso. Eu devo?
• O Helper funciona para fazer ainda mais. Por exemplo, `http://example.com`netpara acesso à rede (novamente, o netoperador pode ser renomeado). rbpara executar uma string como código Ruby. Haverá muito mais desses; sugestões bem-vindas.
• Sem comentários, para que #possa ser usado para outra coisa. Se você quiser um comentário, `comment here`;funcionará bem. (Talvez #possa substituir `a função)
• Ele será completamente reescrito de forma que será muito mais fácil adicionar funções. Basicamente, o código será mais legível. (Você viu a fonte GolfScript? :/)
• Ele estará no Github para que possa ser trabalhado em colaboração. Vou licenciá-lo no MIT ou algo assim.
• Nenhuma nova linha final, portanto, as cotações mais baratas funcionam: P

E eu estou separando essas coisas porque acho que são as mudanças mais drásticas e úteis (exceto, talvez, a adição de ponto flutuante):

• Ele terá muitas funções Ruby integradas. Por exemplo, shuffle(que pode ser abreviado para sf) (assumiu 9 caracteres anteriormente ), tr(anteriormente 14 caracteres ), sample( sm, anteriormente .,rand=), flatten( flanteriormente ???), etc.
• Será esmagado, como Rebmu. Por exemplo, agora você pode fazer ~:a0<{0a-}aIF(usando um nome de variável de letra) em vez de ~:$0<{0$-}$if(substituir a função de classificação). (exemplo daqui ). Observe que, dessa maneira, não diferencia maiúsculas de minúsculas, e números não são permitidos em nomes de variáveis. Tudo bem na minha opinião, pois é uma linguagem de golfe: P
• Ele terá depuração. Adicionarei a capacidade de fornecer um sinalizador especificando delimitadores de matriz, delimitadores de elemento etc., saída de número (racional, float ou int?), Percorrendo as instruções uma por vez, tokenizando e emitindo cada token em vez de executar o programa, etc.

Então, minha pergunta é: o que há para melhorar? O que você acha que devo adicionar?

Alguma outra idéia para isso, antes de começar a codificá-lo?

E / S flexível

No momento, o Golfscript não pode ser usado para programas interativos. Proponho que sejam adicionadas algumas funções para entrada explícita (por exemplo readline, getchare amigos). O intérprete deve verificar se o programa os utiliza antes de executá-lo.

Se o programa não chamar nenhuma função de entrada, o intérprete deve agir como o Golfscript normalmente.

Eu não esperaria que o intérprete detecta funções de entrada no código avaliado gerado em tempo de execução, mas se, de alguma forma, puder fazer isso, parabéns.

Built-ins mais curtos

Aliases de caractere único para todos os comandos internos que não os possuem. Eu usaria basemuito mais se fosse justo B.

Div-mod combinado

Este é um nicho um pouco mais do que algumas sugestões, mas, ao trabalhar em programas de teoria dos números, frequentemente me pego desejando uma operação que apareça dois números inteiros ae bda pilha e empurre a/be a%b. (Atualmente é isso 1$1$/@@%).

Números

Altere o lexer de modo que 0 à esquerda não faça parte de um número:

# current behaviour
01     # -> 1

# new
01     # -> 0 1

Números negativos também devem ser escritos com _:

# current behaviour
1 2-3   # -> -1 3

# new
1 2_3     # -> 1 2 -3

Acesso a toda a pilha

GolfScript é uma linguagem baseada em pilha, mas o acesso a todos, exceto os três principais itens da pilha, é limitado <integer>$para copiar o enésimo item. Seria útil ter algo como o rollcomando PostScript para facilitar o trabalho com mais de três variáveis ​​"ativas".

Idealmente, haveria versões de um e dois argumentos, mas se não houver nomes suficientes por aí, o argumento deverá ter preferência por um de um caractere.

O one-arg one leva apenas o número de itens para rolar. Por exemplo 1 roll, não faz nada; 2 rollé equivalente a \; 3 rollé equivalente a @; 4 rolle para números mais altos não tem um equivalente existente; o mais próximo possível é algo como

]-4/()\+\+[]*-1%~

(e isso nem lida com não-inteiros em determinadas posições da pilha, ou ativos [, e quase certamente quebra dentro de loops também).

O de dois argumentos também leva uma quantidade para rolar; a b roll2é equivalente a {a roll}b*.

CJam

Eu implementei "um GolfScript aprimorado" e ele é chamado CJam - http://sf.net/p/cjam
Agora, no segundo lançamento (versão 0.6), ele já possui muitos, senão a maioria dos recursos discutidos aqui. Vou tentar listá-los:

• ainda escrito em Ruby - não, java
• usando `como um delimitador de string - não, mas usa strings com aspas duplas com escape mínimo ( \somente escape \e ")
• ponto flutuante - suportado, mas apenas padrão "duplo", precisão não arbitrária
• converter tipos para outros tipos - sim
• expressões regulares - ainda não, mas planejadas; usará seqüências regulares com operadores especiais
• Objetos Arquivo e Data - não, mas podem obter a data / hora atual
• hashes - supondo que sejam como python dicts ou java maps, eles não são suportados (pode ser considerado no futuro)
• funções auxiliares para fazer ainda mais - sim, muito
• `http://example.com`net - "example.com"g
• executar uma string como código Ruby - não
• sem comentários - exatamente, #usado para outra coisa,"comments like this";
• mais fácil adicionar funções - acho que sim, mas também sou tendenciosa :)
• no Github - ainda melhor (na minha opinião, por favor, não atire) - no SourceForge, usando hg
• licenciado pelo MIT - sim
• nenhuma nova linha final - direita
• embaralhar - mr
• tr - er
• amostra - não concluída, _,mr=
• achatar - não feito, mas provavelmente mais fácil de alcançar
• não - mas os identificadores não precisam ser separados

• depuração - apenas rastreios de pilha e edoperador para mostrar a pilha

• E / S flexível - sim, mas apenas entrada explícita

• built-ins mais curtos - sim, b= base, z= zip
• 0 à esquerda separado - não, mas pode usar variáveis ​​predefinidas
• desambiguar -- sim, mas não com _; 1 2-3-> 1 2 -3; 1 2m3->-1 3
• rolar / girar a pilha - não
• conjunto de matrizes - t
• divmod - md
• mude o lexer (para identificadores) - sim, mais abaixo
• produto cartesiano - não exatamente o mesmo, mas sim, m*
• operadores unicode - não
• identificadores de caracteres únicos - operadores predefinidos têm 1 ou 2 caracteres e as variáveis ​​são letras maiúsculas de um caractere; todos eles podem ser concatenados sem confundir o lexer / parser
• operadores em blocos - não
• classificação estável - sim
• transformar símbolos de volta em blocos de código - não, mas pode adicionar mais tarde
• data / hora atual - et
• linha de comando args - ea
• separando claramente os embutidos - sim, mas os capitais são variáveis; built-ins são ou começam com caracteres especiais e minúsculos
• min e max - sim, atualmente apenas para 2 valores: e<,e>
• valor absoluto - z(GolfScript tem abs, não falta)
• soma e produto de uma matriz - :+,:*
• Distância Manhattan - não
• chr - c(converte em um caractere, não em uma string)
• derrame uma string na pilha - as strings CJam são feitas de caracteres, não de números; derramar os personagens ainda está{}/
• uma versão :disso consome o que é armazenado - não
• operadores para >=, <=- não, use <!,>!
• base64 e zlib - não
• atalhos para 1 $, 2 $, 3 $, 4 $, 5 $ - não
• copie os dois principais itens da pilha - planejados; por enquanto use1$1$
• variáveis ​​locais - não
• Recursos do HQ9 + - não, obrigado

O CJam possui muito mais recursos, confira https://sourceforge.net/p/cjam/wiki/Operators/

Mude o lexer

O lexer do GolfScript trata um identificador Ruby (qualquer coisa que corresponda ao regex [_a-zA-Z][_a-zA-Z0-9]*) como um único token. Se, em vez disso, fosse tratado [a-zA-Z]+como um token, seria liberado _para ser incorporado e permitiria que uma variável alfa fosse seguida por um número inteiro literal sem separar o espaço em branco.

Aliases Unicode

Comandos de vários caracteres podem ter aliases unicode. Isso economizaria a pontuação quando a contagem fosse contada em caracteres e não em bytes.

Classificação estável

Os $blocos internos devem executar uma classificação estável.

Operador de conjunto de matrizes

["A" "B" "C" "D" "E" "F"] -1 4 S    # -> ["A" "B" "C" "D" -1 "F"]

Qualquer embutido que possamos disponibilizar para isso?

Identificadores de caracteres únicos

Não é como se uma solução de código de golfe tivesse muitas variáveis. E economizaria em espaços.

% conforme incorporado para o produto

[1 2][1 2 3]%  # -> [[[1 1][1 2][1 3]][[2 1][2 2][2 3]]]

Suporte Regex

A falta de suporte a regex sempre me pareceu estranho em um idioma projetado para jogar golfe. Seria ótimo ter

• <string> <string> <string> y(ou seja tr, usando o alias de um caractere do Perl)
• <string> <string> <string> s (substituto)
• <string> <string> <block> s (substituir com retorno de chamada)
• <string> <string> m (Combine)

Builtins para data / hora atuais

Atualmente, é muito peculiar obter data / hora usando o Ruby evals.

D     # -> [2013 12 31]
T     # -> [23 59 59]

Faça |, & e ^ built-ins fazerem algo útil em blocos

Por exemplo, <array/string> <block> |pode ser usado como função de índice

[0 -10 -20 30 40 -50 60] {0<} |   # -> [1 2 5]

Alguma idéia para <array/string> <block> &ou <array/string> <block> ^?

Uma maneira de transformar símbolos novamente em blocos de código

Atualmente, podemos vincular blocos de código a símbolos com :, mas não há como reverter o processo: executar um símbolo vinculado a um bloco de código apenas executa o bloco.

Eu posso ver algumas maneiras de implementar isso:

1. adicione nova sintaxe, por exemplo, #foopara enviar o valor foopara a pilha, mesmo que seja um bloco de código, ou

2. adicione um operador para expandir todos os símbolos em um bloco de código, para que (usando _como o novo operador), por exemplo {2*}:dbl; {dbl dbl}_, produza {2* 2*}.

Eu posso ver vantagens para ambos os métodos. O último poderia substituir o primeiro, ao custo de dois caracteres extras (em {foo}_vez de #foo), mas posso ver alguns aplicativos em potencial para a sintaxe anterior, onde esses dois caracteres seriam proibitivos (por exemplo, usar em array #func %vez de array {func} %).

Enquanto isso, a sintaxe anterior poderia ser usada para substituir a última se houvesse uma maneira conveniente de iterar os tokens em um bloco de código (que poderia ser útil por si só).

Em ambos os casos, eu proporia que os símbolos de expansão vinculados aos incorporados nativos (ou seja, implementados no código Ruby) devolveriam algum tipo de stub que poderia ser chamado para obter a funcionalidade do embutido, além de ser impossível ou apenas improvável de ser substituído. Por exemplo #$(ou {$}_) poderia retornar {builtin_dollar}, por exemplo , onde builtin_dollarconteria a implementação real do $built-in (e #builtin_dollarou {builtin_dollar}_deveria apenas retornar por {builtin_dollar}si mesmo).

Isso permitiria que os internos fossem redefinidos sem perder o acesso às suas funcionalidades (consulte minha sugestão anterior ), de modo que, se por algum motivo eu quisesse trocar os significados de $e @, eu poderia apenas fazer #$ #@ :$; :@;(ou {$}_ {@}_ :$; :@;).

Predefinição de variável com argumentos de linha de comando

Infelizmente, não há nenhum caractere deixado sem atribuição, mas talvez possamos usá A-lo?

Funções nativas de Ruby que devo implementar

Este é o Wiki da comunidade; fique à vontade para editar e adicionar as funções que você acha que devo implementar!

Formato: " nativeFunctionName( nameInMyLanguage)"

• shuffle( sf)
• tr( tr)
• sample( sm)

Aproveite também os recursos do APL e HQ9 +!

• Atalhos, como no APL. EDIT: acabou de ver a resposta "aliases unicode". Foi isso que eu quis dizer :)
• Outros atalhos orientados para o golfe, como no H9 +, HQ9 +, CHIQRSX9 +

Separando claramente os embutidos

por exemplo, capitais: embutidos; tornando B viável para a base

Variáveis ​​/ fechamentos locais

Uma coisa que realmente sinto falta no GolfScript é a capacidade de alterar temporariamente o valor de um símbolo .

Em particular, atualmente não há como substituir temporariamente o significado de um built-in "primitivo": uma vez que você redefine, por exemplo, $nunca mais classificará nada nesse programa. (Bem, não sem escrever sua própria implementação de classificação, pelo menos.) Seria muito bom poder dizer, por exemplo, que nesse bloco de código $ significa outra coisa, mas ainda assim mantenha o significado normal em outro lugar.

Relacionado ao acima, seria bom vincular símbolos em um bloco de código ao seu valor atual . Claro, eu posso escrever, dizer {$-1%}:rsorte poder usar rsortpara classificar e reverter uma matriz, mas isso funciona apenas desde que a definição de $(ou -1ou %) não mude, pois minha rsortfunção ainda está chamando o símbolo global $. Seria bom poder dizer "deixe rsortfazer o que $-1%atualmente faz, mesmo que esses símbolos sejam redefinidos posteriormente".

Em particular, a biblioteca padrão pode usar esse tipo de ligação. É meio surpreendente perceber que, digamos, mudar nmuda o comportamento de puts, ou que redefinir !completamente atrapalha xor. (Mais uma vez, deve-se ter cautela aqui, já que, em particular, a capacidade de alterar o comportamento de putsacaba sendo a única maneira de evitar a impressão de uma nova linha final na versão atual do GS.)

Editar: Ser capaz de transformar símbolos novamente em blocos de código ajudaria bastante a implementar essa funcionalidade. Em particular, a {foo}_sintaxe sugerida nessa resposta efetivamente executaria um nível de ligação estática, expandindo todos os símbolos em um bloco de código. Combine isso com um combinador de ponto de fixação para ligação estática profunda e Bob é seu tio ...

Mais funções integradas

Faça com que todas as variáveis ​​de letra única az e AZ executem alguma função genérica e útil. Alguns built-ins que estão faltando:

• min e max: todos ou alguns dos 2 principais valores da pilha, os principais n valores da pilha, em uma matriz
• valor absoluto
• soma e produto de uma matriz. por que fazer {+}*quando você pode fazer S? Você tem 52 funções para trabalhar aqui!
• Distância de Manhattan (ou seja, x1 y1 x2 y2 --> abs(x2-x1)+abs(y2-y1)agora teria que ser @-A@@-A+se Aé um valor absoluto embutido. Concedido isso apenas surgiram os resultados do meu post mais recente, mas sempre achei que seria uma boa maneira de expandir o script de golfe: escreva o que funções seriam úteis para ter, coletá-las e adicioná-las como integradas.
• Converta um número inteiro em uma cadeia de um caractere (equivalente a de python chr).
• Derrame uma corda na pilha (atualmente {}/)
• Uma versão :disso consome o que está armazenado. Isso teria que não ficar 'preso' aos identificadores para ser útil.
• Operadores para >=,<=
• Como alguém sugeriu, uma maneira de colocar uma variável contendo um bloco na pilha sem executá-la. Então você pode reduzir ifs do formulário 1{\}{|}ifpara algo como1?\?|if
• Conversão base64 integrada e suporte a zlib para fazer com que os dados de incorporação ocupem menos caracteres
• Além da base64, faça uma codificação base93 personalizada (usando todos os caracteres imprimíveis que não sejam o delimitador de string).
• Atalhos para 1$, 2$, 3$, 4$,5$
• Um operador para copiar os dois principais itens da pilha como estão, ou seja, \.@.@\

Seria bom se o valor escrito ou calculado na última linha de uma função fosse retornado automaticamente