Estoy planeando escribir un GolfScript mejorado para programas aún más cortos que pueden hacer más cosas. Esto no es un desafío; Es una solicitud de retroalimentación y consejos sobre lo que debo hacer. (ver etiquetas)

^{No estoy seguro de si esto debería ser Community Wiki. Si crees que sí, solo marca un moderador para convertirlo :)}

Este lenguaje será muy similar a GolfScript. Todavía está escrito en Ruby. Sin embargo, tiene algunas diferencias:

• Utilizándolo `como delimitador de cadena, porque es un carácter poco común, por lo que se necesitará menos escape. (Otro personaje puede reemplazar su función, como #(más sobre eso más adelante)). \`para escapar de un backtick, \\para escapar de una barra diagonal inversa, y no hay otras secuencias de escape. Si necesita una nueva línea, simplemente pegue una nueva línea literal real en la cadena.
• Usando Ruby's Rationals para punto flotante de precisión arbitraria, uno de los principales defectos de GolfScript.
• La capacidad de convertir tipos a otros tipos. Por ejemplo, puede convertir un bloque en una cadena.
• Expresiones regulares. Probablemente creado con "...". Los operadores también estarán sobrecargados por ellos. Por ejemplo, "\W"~{`Invalid: non-word character`}{`OK`}if. Se ejecutará automáticamente cuando se empuje desde una variable, como bloques.
• Objetos de archivo y fecha, para hacer más cosas que eran imposibles en GolfScript. Estos no tendrán literales, pero tendrán funciones para inicializarlos, como `file.txt`fl(el nombre de la función de creación de archivos puede cambiar).
• Hashes tal vez, pero no estoy seguro de eso. ¿Debería?
• Funciones de ayuda para hacer aún más. Por ejemplo, `http://example.com`netpara el acceso a la red (nuevamente, se netpuede cambiar el nombre del operador). rbejecutar una cadena como código Ruby. Habrá muchos más de estos; Sugerencias bienvenidas.
• No hay comentarios, por lo que #puede usarse para otra cosa. Si quieres un comentario, `comment here`;funcionará bien. (Tal vez #pueda reemplazar `la función de)
• Se reescribirá por completo de manera que sea mucho más fácil agregar funciones. Básicamente, el código será más legible. (¿Has visto la fuente de GolfScript? :/)
• Estará en Github para que se pueda trabajar en colaboración. Lo licenciaré bajo MIT o algo así.
• No hay una nueva línea final, por lo que las quines truculentas funcionan: P

Y los estoy diferenciando porque creo que son los cambios más drásticos y útiles (excepto quizás agregar punto flotante):

• Tendrá muchas funciones de Ruby integradas. Por ejemplo, shuffle(que puede abreviarse como sf) (anteriormente tomaba 9 caracteres ), tr(anteriormente 14 caracteres ), sample( sm, previamente .,rand=), flatten( fl, anteriormente ???), etc.
• Será aplastado, como Rebmu. Por ejemplo, ahora puede hacerlo ~:a0<{0a-}aIF(usando un nombre de variable de letra) en lugar de ~:$0<{0$-}$if(sobrescribiendo la función de clasificación). (ejemplo de aquí ). Tenga en cuenta que de esta manera, no distingue entre mayúsculas y minúsculas, y no se permiten números en los nombres de variables. Esto está bien en mi opinión ya que es un lenguaje de golf: P
• Tendrá depuración. Agregaré la capacidad de proporcionar un indicador que especifique delimitadores de matriz, delimitadores de elementos, etc., salida de número (racional, flotante o int?), Siguiendo las instrucciones de una en una, tokenizando y generando cada token en lugar de ejecutar el programa, etc.

Entonces, mi pregunta es: ¿qué hay para mejorar? ¿Qué crees que debería agregar?

¿Alguna otra idea para esto, antes de comenzar a codificarlo?

E / S flexible

Golfscript no se puede utilizar actualmente para programas interactivos. Propongo que se agreguen algunas funciones para la entrada explícita (es decir readline, getchary amigos). El intérprete debería ver si el programa los usa antes de ejecutarlo.

Si el programa no llama a ninguna función de entrada, el intérprete debe actuar como lo hace normalmente Golfscript.

No esperaría que el intérprete detecte las funciones de entrada en el código evaluado generado en tiempo de ejecución, pero si de alguna manera puede hacer eso, felicitaciones.

Incorporaciones más cortas

Alias ​​de un solo carácter para todos los comandos integrados que no los tienen. Usaría basemucho más si fuera justo B.

Div-mod combinado

Este es un poco más nicho que algunas de las sugerencias, pero cuando trabajo en programas de teoría de números, frecuentemente me encuentro con ganas de una operación que saca dos enteros ay bde la pila y empuja a/by a%b. (En la actualidad esto es 1$1$/@@%).

Números

Cambie el lexer de modo que el 0 inicial no forme parte de un número:

# current behaviour
01     # -> 1

# new
01     # -> 0 1

También los números negativos deben escribirse con _:

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

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

Acceso a toda la pila.

GolfScript es un lenguaje basado en la pila, pero el acceso a todos menos los tres elementos principales de la pila se limita <integer>$a copiar el enésimo elemento. Sería útil tener algo como el rollcomando PostScript para que sea más fácil trabajar con más de tres variables "en vivo".

Idealmente, habría versiones de un argumento y de dos argumentos, pero si no hay suficientes nombres, entonces el argumento de un argumento debería tener preferencia por uno de un carácter.

El de un argumento solo toma el número de elementos para rodar. Por ejemplo 1 roll, no hace nada; 2 rolles equivalente a \; 3 rolles equivalente a @; 4 rolly para números más altos no tiene un equivalente existente; lo más cercano posible es algo así como

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

(y eso ni siquiera maneja números no enteros en ciertas posiciones en la pila, o activos [, y casi con seguridad también se rompe dentro de los bucles).

El de dos argumentos también toma una cantidad para rodar; a b roll2es equivalente a {a roll}b*.

CJam

He implementado "un GolfScript mejorado" y se llama CJam - http://sf.net/p/cjam
Ahora en la segunda versión (versión 0.6) ya tiene muchas, si no la mayoría de las características discutidas aquí. Trataré de enumerarlos:

• todavía escrito en Ruby - no, java
• usando `como delimitador de cadena: no, pero usa cadenas entre comillas dobles con \escapes mínimos ( solo escapes \y ")
• coma flotante - compatible, pero solo estándar "doble", no precisión arbitraria
• convertir tipos a otros tipos: sí
• expresiones regulares, aún no, pero planificadas; usará cadenas regulares con operadores especiales
• Objetos de archivo y fecha: no, pero puede obtener la fecha / hora actual
• hashes: suponiendo que sean como dictados de python o mapas de Java, entonces no son compatibles (puede considerar en el futuro)
• funciones auxiliares para hacer aún más, sí, mucho
• `http://example.com`net - "example.com"g
• ejecutar una cadena como código Ruby - no
• sin comentarios, exactamente, #usado para otra cosa,"comments like this";
• más fácil de agregar funciones: creo que sí, pero también soy parcial :)
• en Github - incluso mejor (en mi opinión, por favor no dispare) - en SourceForge, usando hg
• licenciado bajo MIT - sí
• sin nueva línea final - derecha
• barajar mr
• tr - er
• muestra - no hecho, _,mr=
• aplanar: no hecho, pero probablemente más fácil de lograr
• mushed - no, pero los identificadores no necesitan separarse

• depuración: solo trazas de pila y edoperador para mostrar la pila

• E / S flexible: sí, pero solo entrada explícita

• incorporaciones más cortas: sí, b= base, z= zip
• Separe el 0 inicial - no, pero puede usar variables predefinidas
• desambiguate -- sí, pero no con _; 1 2-3-> 1 2 -3; 1 2m3->-1 3
• rodar / rotar la pila - no
• conjunto de matriz t
• divmod - md
• cambiar el lexer (para identificadores) - sí, más abajo
• producto cartesiano: no es exactamente lo mismo, pero sí, m*
• operadores unicode - no
• identificadores de un solo carácter: los operadores predefinidos tienen 1 o 2 caracteres y las variables son letras mayúsculas de un solo carácter; todos pueden ser concatenados sin confundir al lexer / parser
• operadores en bloques - no
• tipo estable - sí
• Convierta los símbolos nuevamente en bloques de código, no, pero puede agregarlos más tarde
• fecha / hora actual - et
• línea de comando args - ea
• separando claramente las incorporaciones, sí, pero las mayúsculas son variables; las incorporaciones son o comienzan con minúsculas y caracteres especiales
• min y max - Sí, en la actualidad sólo para 2 valores: e<,e>
• valor absoluto - z(GolfScript tiene abs, no falta)
• suma y producto de una matriz - :+,:*
• Distancia de Manhattan - no
• chr - c(se convierte en un carácter, no en una cadena)
• derrame una cadena sobre la pila: las cadenas de CJam están hechas de caracteres, no de números; para derramar los personajes sigue siendo{}/
• una versión de :eso consume lo que está almacenado - no
• operadores para >=, <=- no, uso <!,>!
• base64 y zlib - no
• atajos por 1 $, 2 $, 3 $, 4 $, 5 $ - no
• copie los dos elementos principales de la pila: planeado; por ahora usar1$1$
• variables locales - no
• Funciones HQ9 +: no, gracias

CJam tiene muchas más funciones, consulte https://sourceforge.net/p/cjam/wiki/Operators/

Cambiar el lexer

El lexer de GolfScript trata un identificador Ruby (cualquier cosa que coincida con la expresión regular [_a-zA-Z][_a-zA-Z0-9]*) como un token único. Si en cambio, se trata [a-zA-Z]+como un token que se liberaría _para ser incorporado y permitiría que una variable alfa fuera seguida de un entero literal sin separar espacios en blanco.

Alias ​​Unicode

Los comandos de varios caracteres pueden tener alias unicode. Esto ahorraría en la puntuación cuando la puntuación se cuenta en caracteres y no en bytes.

Tipo estable

La $construcción en bloques debe realizar una clasificación estable.

Operador de conjunto de matrices

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

¿Algún incorporado que podamos poner a disposición para eso?

Identificadores de un solo carácter

No es como si una solución de código de golf tuviera demasiadas variables. Y ahorraría en espacios.

% como incorporado para el producto

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

Soporte de expresiones regulares

La falta de soporte de expresiones regulares siempre me ha parecido extraño en un lenguaje diseñado para jugar al golf. Sería genial tener

• <string> <string> <string> y(alias tr, usando el alias one-char de Perl para ello)
• <string> <string> <string> s (sustituir)
• <string> <string> <block> s (sustituir con devolución de llamada)
• <string> <string> m (partido)

Construido para la fecha / hora actual

Actualmente es muy peculiar obtener fecha / hora usando evaluaciones de Ruby.

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

Los complementos Make |, & y ^ hacen algo útil en bloques

Por ejemplo, <array/string> <block> |se puede usar como función de índice

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

¿Alguna idea para <array/string> <block> &o <array/string> <block> ^?

Una forma de convertir los símbolos nuevamente en bloques de código

Actualmente, podemos vincular bloques de código a símbolos con :, pero no hay forma de revertir el proceso: la ejecución de un símbolo vinculado a un bloque de código solo ejecuta el bloque.

Puedo ver un par de formas de implementar esto:

1. agregar nueva sintaxis, por ejemplo, #foopara empujar el valor de fooa la pila, incluso si es un bloque de código, o

2. agregue un operador para expandir cada símbolo en un bloque de código, de modo que (utilizando _como el nuevo operador), por ejemplo {2*}:dbl; {dbl dbl}_, produciría {2* 2*}.

Puedo ver ventajas para ambos métodos. El último podría sustituir al primero, a costa de dos caracteres adicionales (en {foo}_lugar de #foo), pero puedo ver algunas aplicaciones potenciales para la sintaxis anterior donde esos dos caracteres serían prohibitivos (por ejemplo, usar en array #func %lugar de array {func} %).

Mientras tanto, la sintaxis anterior podría usarse para reemplazar la segunda si hubiera una forma conveniente de iterar sobre los tokens en un bloque de código (que de todos modos podría ser útil por sí solo).

En cualquier caso, propondría que los símbolos expandibles que están vinculados a las funciones integradas nativas (es decir, implementadas en el código Ruby) devuelvan algún tipo de código auxiliar que se pueda invocar para obtener la funcionalidad de la función integrada, aunque sea imposible o simplemente es poco probable que se anule. Por ejemplo #$(o {$}_) podría regresar {builtin_dollar}, por ejemplo , donde builtin_dollarcontendría la implementación real de la función $incorporada (y / #builtin_dollaro {builtin_dollar}_simplemente debería regresar {builtin_dollar}).

Esto permitiría redefinir las incorporaciones sin perder el acceso a su funcionalidad (vea mi sugerencia anterior ), de modo que si, por alguna razón, quisiera cambiar los significados de $y @, simplemente podría hacer #$ #@ :$; :@;(o {$}_ {@}_ :$; :@;).

Preset variable con argumentos de línea de comando

Desafortunadamente, no queda ningún personaje sin asignar, pero ¿tal vez podamos usarlo Apara eso?

Funciones nativas de Ruby que debería implementar

Esto es Wiki de la comunidad; ¡siéntase libre de editar y agregar las funciones que cree que debería implementar!

Formato: " nativeFunctionName( nameInMyLanguage)"

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

¡Tome características de APL y HQ9 + también!

• Atajos, como en APL. EDITAR: acabo de ver la respuesta "alias unicode". A eso me refería :)
• Otros atajos orientados al golf, como en H9 +, HQ9 +, CHIQRSX9 +

Separando claramente los empotrados

por ejemplo, mayúsculas: incorporados; haciendo B para la base factible

Variables locales / cierres

Una cosa que realmente extraño en GolfScript es la capacidad de cambiar temporalmente el valor de un símbolo .

En particular, actualmente no hay forma de anular temporalmente el significado de un "primitivo" integrado: una vez que, por ejemplo, redefinir $, nunca volverá a ordenar nada en ese programa. (Bueno, no sin escribir su propia implementación de clasificación, al menos). Sería realmente bueno poder decir, por ejemplo, que en este bloque de código $ significa algo más, pero aún así mantener el significado normal en otro lugar.

En relación con lo anterior, sería bueno vincular símbolos en un bloque de código a su valor actual . Claro, puedo escribir, decir, {$-1%}:rsorty ser capaz de usar rsortpara ordenar e invertir una matriz, pero eso funciona solo mientras la definición de $( -1oo %) no cambie, ya que mi rsortfunción todavía está llamando al símbolo global $. Sería bueno poder decir "dejar de rsorthacer lo $-1%que hace actualmente, incluso si esos símbolos se redefinen más tarde".

En particular, la biblioteca estándar podría usar este tipo de enlace. Es sorprendente darse cuenta de que, por ejemplo, cambiar los ncambios en el comportamiento de puts, o que redefinir !completamente arruina xor. (Por otra parte, se debe tener precaución aquí, ya que, en particular, la capacidad de cambiar el comportamiento de putsresulta ser la única forma de evitar imprimir una nueva línea final en la versión actual de GS).

Editar: Ser capaz de convertir los símbolos nuevamente en bloques de código contribuiría en gran medida a implementar esta funcionalidad. En particular, la {foo}_sintaxis sugerida en esa respuesta realizaría efectivamente un nivel de enlace estático al expandir todos los símbolos en un bloque de código. Combina eso con un combinador de punto fijo para una unión estática profunda, y Bob es tu tío ...

Más funciones incorporadas

Haga que todas las variables de una letra az y AZ realicen alguna función útil genérica. Algunos complementos que faltan:

• min y max: todos o algunos de los 2 valores principales de la pila, los valores superiores de la pila n, sobre una matriz
• valor absoluto
• suma y producto de una matriz. ¿Por qué {+}*cuando puedes hacer S? ¡Tienes 52 funciones para trabajar aquí!
• Distancia de Manhattan (es decir, x1 y1 x2 y2 --> abs(x2-x1)+abs(y2-y1)ahora tendría que ser @-A@@-A+si Aes un valor absoluto incorporado. Es cierto que esto solo surgió como pistas de mi publicación más reciente, pero siempre pensé que sería una buena manera de expandir golfscript: escriba qué sería útil tener funciones, recopilarlas y agregarlas como integradas.
• Convierta un número entero en una cadena de un carácter (equivalente a la de Python chr).
• Derramar una cuerda sobre la pila (actualmente {}/)
• Una versión de :eso consume lo que está almacenado. Esto tendría que no quedar 'atascado' en los identificadores para ser útil.
• Operadores para >=,<=
• Como alguien sugirió, una forma de poner una variable que contiene un bloque en la pila sin ejecutarla. Entonces podría reducir los ifs de la forma 1{\}{|}ifa algo como1?\?|if
• Conversión base64 incorporada y soporte zlib para hacer que la inserción de datos tome menos caracteres
• Más allá de base64, cree una codificación base93 personalizada (utilizando todos los caracteres imprimibles que no sean el delimitador de cadena).
• Atajos para 1$, 2$, 3$, 4$,5$
• Un operador para copiar los dos elementos superiores de la pila tal como están, es decir \.@.@\

Sería bueno si el valor escrito o calculado en la última línea de una función se devuelve automáticamente