Je prévois d'écrire un GolfScript amélioré pour des programmes encore plus courts qui peuvent faire plus de choses. Ce n'est pas un défi; c'est une demande de rétroaction et de conseils sur ce que je dois faire. (voir tags)

^{Je ne sais pas si cela devrait être un wiki communautaire. Si vous le pensez, il suffit de signaler un modérateur pour le convertir :)}

Ce langage sera très similaire à GolfScript. Il est toujours écrit en Ruby. Cependant, il présente quelques différences:

• Utilisation `comme délimiteur de chaîne, car il s'agit d'un caractère inhabituel, donc moins d'échappement sera nécessaire. (Un autre personnage peut remplacer sa fonction, comme #(plus à ce sujet plus tard)). \`pour échapper à un backtick, \\pour échapper à une barre oblique inverse, et il n'y a pas d'autres séquences d'échappement. Si vous avez besoin d'une nouvelle ligne, collez simplement une nouvelle ligne littérale réelle dans la chaîne.
• Utilisation de Ruby Rationalpour une virgule flottante de précision arbitraire, l'un des principaux défauts de GolfScript.
• La possibilité de convertir des types en d'autres types. Par exemple, vous pouvez convertir un bloc en chaîne.
• Expressions régulières. Probablement créé avec "...". Les opérateurs seront également surchargés pour eux. Par exemple "\W"~{`Invalid: non-word character`}{`OK`}if,. S'exécute automatiquement lorsqu'il est poussé à partir d'une variable, comme des blocs.
• Objets Fichier et Date, pour faire plus de choses qui étaient impossibles dans GolfScript. Ceux-ci n'auront pas de littéraux, mais auront des fonctions pour les initialiser, comme `file.txt`fl(le nom de la fonction de création de fichier peut changer).
• Hashs peut-être, mais je ne suis pas sûr à ce sujet. Devrais-je?
• Fonctions d'aide pour faire encore plus. Par exemple, `http://example.com`netpour l'accès au réseau (encore une fois, l' netopérateur peut être renommé). rbpour exécuter une chaîne en tant que code Ruby. Il y en aura beaucoup plus; suggestions bienvenues.
• Pas de commentaires, donc ça #peut être utilisé pour autre chose. Si vous voulez un commentaire, `comment here`;cela fonctionnera bien. (Peut-être #peut remplacer `la fonction de)
• Il sera complètement réécrit de manière à ce qu'il soit beaucoup plus facile d'ajouter des fonctions. Fondamentalement, le code sera plus lisible. (Avez-vous vu la source GolfScript? :/)
• Il sera sur Github afin qu'il puisse être travaillé en collaboration. Je vais le concéder sous licence MIT ou quelque chose.
• Pas de nouvelle ligne finale, donc les quines tricheuses fonctionnent: P

Et je les distingue parce que je pense que ce sont les changements les plus drastiques et les plus utiles (sauf peut-être l'ajout de virgule flottante):

• Il aura de nombreuses fonctions Ruby intégrées. Par exemple, shuffle(qui peut être abrégé en sf) (a précédemment pris 9 caractères ), tr(auparavant 14 caractères ), sample( sm, précédemment .,rand=), flatten( fl, précédemment ???), etc.
• Il sera écrasé, comme Rebmu. Par exemple, vous pouvez maintenant faire ~:a0<{0a-}aIF(en utilisant un nom de variable de lettre) au lieu de ~:$0<{0$-}$if(écraser la fonction de tri). (exemple d'ici ). Notez que de cette façon, il ne respecte pas la casse et les nombres ne sont pas autorisés dans les noms de variables. C'est correct à mon avis car c'est une langue de golf: P
• Il aura un débogage. J'ajouterai la possibilité de fournir un indicateur spécifiant les délimiteurs de tableau, les délimiteurs d'éléments, etc., la sortie numérique (rationnelle, flottante ou int?), Parcourant les instructions une par une, jetant et sortant chaque jeton au lieu d'exécuter le programme, etc.

Alors, ma question est: qu'est-ce qu'il y a à améliorer? Que pensez-vous que je devrais ajouter?

Avez-vous d'autres idées à ce sujet avant de commencer à le coder?

E / S flexibles

Golfscript ne peut actuellement pas être utilisé pour des programmes interactifs. Je propose d'ajouter quelques fonctions pour une entrée explicite (c. readline-à- d . getcharEt amis). L'interpréteur doit voir si le programme les utilise avant de l'exécuter.

Si le programme n'appelle aucune fonction d'entrée, l'interpréteur doit agir comme Golfscript le fait normalement.

Je ne m'attendrais pas à ce que l'interpréteur détecte les fonctions d'entrée dans le code évalué généré lors de l'exécution, mais si cela peut le faire, bravo.

Intégrés plus courts

Alias ​​à un seul caractère pour toutes les commandes intégrées qui n'en ont pas. J'en utiliserais basebeaucoup plus si c'était juste B.

Div-mod combiné

Ceci est un peu plus créneau que quelques - unes des suggestions, mais lorsque l'on travaille sur les programmes en nombre théorétique je trouve souvent moi - même vouloir une opération qui apparaît deux entiers aet bde la pile et pousse a/bet a%b. (À l'heure actuelle, c'est 1$1$/@@%).

Nombres

Modifiez le lexeur de sorte que le 0 en tête ne fasse pas partie d'un nombre:

# current behaviour
01     # -> 1

# new
01     # -> 0 1

Les nombres négatifs doivent également être écrits à la _place:

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

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

Accès à toute la pile

GolfScript est un langage basé sur la pile, mais l'accès à tous, sauf les trois premiers éléments de la pile, est limité <integer>$à la copie du nième élément. Il serait utile d'avoir quelque chose comme la rollcommande de PostScript pour qu'il soit plus facile de travailler avec plus de trois variables "live".

Idéalement, il y aurait des versions à un argument et à deux arguments, mais s'il n'y a pas assez de noms, le seul argument devrait avoir la préférence pour un seul caractère.

Celui à un argument prend simplement le nombre d'objets à lancer. Par exemple, 1 rollne fait rien; 2 rollest équivalent à \; 3 rollest équivalent à @; 4 rollet pour les nombres supérieurs n'a pas d'équivalent existant; le plus proche possible est quelque chose comme

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

(et cela ne gère même pas les non entiers à certaines positions de la pile, ou actifs [, et se casse presque certainement aussi à l'intérieur des boucles).

Celui à deux arguments prend également un montant à rouler; a b roll2est équivalent à {a roll}b*.

CJam

J'ai implémenté "un GolfScript amélioré" et il s'appelle CJam - http://sf.net/p/cjam
Maintenant, dans la deuxième version (version 0.6), il a déjà beaucoup, sinon la plupart des fonctionnalités discutées ici. Je vais essayer de les lister:

• toujours écrit en Ruby - non, java
• utiliser `comme délimiteur de chaîne - non, mais il utilise des chaînes entre guillemets doubles avec un échappement minimal ( \échappements uniquement \et ")
• virgule flottante - prise en charge, mais uniquement "double" standard, pas de précision arbitraire
• convertir des types en d'autres types - oui
• expressions régulières - pas encore, mais prévues; utilisera des chaînes régulières avec des opérateurs spéciaux
• Objets Fichier et Date - non, mais peuvent obtenir la date / heure actuelle
• hachages - en supposant que ceux-ci sont comme des dict python ou des cartes java, alors ils ne sont pas pris en charge (peut envisager à l'avenir)
• fonctions d'aide pour faire encore plus - oui, beaucoup
• `http://example.com`net - "example.com"g
• exécuter une chaîne en tant que code Ruby - non
• aucun commentaire - exactement, #utilisé pour autre chose,"comments like this";
• plus facile d'ajouter des fonctions - je pense que oui, mais je suis aussi biaisé :)
• sur Github - encore mieux (à mon avis, ne tirez pas) - sur SourceForge, en utilisant hg
• sous licence MIT - oui
• pas de nouvelle ligne finale - droite
• shuffle - mr
• tr - er
• échantillon - pas fait, _,mr=
• aplatir - pas fait, mais probablement plus facile à réaliser
• musclé - non, mais les identifiants n'ont pas besoin d'être séparés

• débogage - uniquement les traces de pile et edopérateur pour afficher la pile

• E / S flexibles - oui, mais uniquement entrée explicite

• encastrés plus courts - oui, b= base, z= zip
• séparer 0 - non, mais peut utiliser des variables prédéfinies
• lever l'ambiguïté -- oui, mais pas avec _; 1 2-3-> 1 2 -3; 1 2m3->-1 3
• rouler / faire pivoter la pile - non
• ensemble de tableaux - t
• divmod - md
• changer le lexer (pour les identifiants) - oui, plus ci-dessous
• produit cartésien - pas exactement le même, mais oui, m*
• opérateurs unicode - non
• identificateurs à un caractère - les opérateurs prédéfinis ont 1 ou 2 caractères et les variables sont des lettres majuscules à un seul caractère; ils peuvent tous être concaténés sans confondre lexer / analyseur
• opérateurs sur blocs - non
• tri stable - oui
• transformer les symboles en blocs de code - non, mais peut ajouter plus tard
• date / heure actuelle - et
• arguments de ligne de commande - ea
• séparer clairement les éléments intégrés - oui, mais les majuscules sont des variables; les éléments intégrés sont ou commencent par des minuscules et des caractères spéciaux
• min et max - oui, actuellement seulement pour 2 valeurs: e<,e>
• valeur absolue - z(GolfScript a abs, ne manque pas)
• somme et produit d'un tableau - :+,:*
• Distance de Manhattan - Non
• chr - c(converti en caractère, pas en chaîne)
• renverser une chaîne sur la pile - les chaînes CJam sont faites de caractères, pas de chiffres; pour renverser les personnages c'est toujours{}/
• une version :qui consomme ce qui est stocké - non
• opérateurs pour >=, <=- non, utiliser <!,>!
• base64 et zlib - non
• raccourcis pour 1 $, 2 $, 3 $, 4 $, 5 $ - non
• copier les deux premiers éléments de la pile - prévu; pour l'instant utiliser1$1$
• variables locales - non
• Fonctionnalités HQ9 + - non, merci

CJam a beaucoup plus de fonctionnalités, consultez https://sourceforge.net/p/cjam/wiki/Operators/

Changer le lexer

Le lexer de GolfScript traite un identificateur Ruby (tout ce qui correspond à l'expression régulière [_a-zA-Z][_a-zA-Z0-9]*) comme un seul jeton. Si au lieu de cela, il était traité [a-zA-Z]+comme un jeton, cela se libérerait _pour être intégré et permettrait à une variable alpha d'être suivie d'un entier littéral sans séparer les espaces.

Alias ​​Unicode

Les commandes à plusieurs caractères peuvent avoir des alias Unicode. Cela permettrait d'économiser sur le score lorsque le score est compté en caractères et non en octets.

Tri stable

Les $blocs intégrés doivent effectuer un tri stable.

Opérateur d'ensemble de tableaux

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

Y a-t-il une fonction intégrée que nous pouvons mettre à disposition pour cela?

Identifiants à un seul caractère

Ce n'est pas comme si une solution de golf de code comportait trop de variables. Et cela économiserait de l'espace.

% intégré au produit

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

Prise en charge de Regex

Le manque de support des regex m'a toujours paru étrange dans un langage conçu pour le golf. Ce serait formidable d'avoir

• <string> <string> <string> y(aka tr, en utilisant l' alias à un caractère de Perl pour cela)
• <string> <string> <string> s (remplacer)
• <string> <string> <block> s (substitut avec rappel)
• <string> <string> m (rencontre)

Builtins pour la date / heure actuelle

Il est actuellement très excentrique d'obtenir la date / l'heure en utilisant des rubis evals.

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

Les commandes intégrées |, & et ^ font quelque chose d'utile sur les blocs

Par exemple, <array/string> <block> |peut être utilisé comme fonction d'index

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

Des idées pour <array/string> <block> &ou <array/string> <block> ^?

Un moyen de transformer les symboles en blocs de code

Actuellement, nous pouvons lier des blocs de code à des symboles avec :, mais il n'y a aucun moyen d'inverser le processus: l'exécution d'un symbole lié à un bloc de code exécute simplement le bloc.

Je peux voir quelques façons de mettre en œuvre cela:

1. ajouter une nouvelle syntaxe, par exemple #foopour pousser la valeur de foodans la pile, même s'il s'agit d'un bloc de code, ou

2. ajouter un opérateur pour développer chaque symbole dans un bloc de code, de sorte que (en utilisant _comme nouvel opérateur), par exemple {2*}:dbl; {dbl dbl}_, produise {2* 2*}.

Je peux voir les avantages des deux méthodes. Ce dernier pourrait se substituer au premier, au prix de deux caractères supplémentaires ( {foo}_au lieu de #foo), mais je peux voir quelques applications potentielles pour l'ancienne syntaxe où ces deux caractères seraient prohibitifs (par exemple, utiliser array #func %au lieu de array {func} %).

Pendant ce temps, l'ancienne syntaxe pourrait être utilisée pour remplacer la seconde s'il existait un moyen pratique d'itérer d'une manière ou d'une autre sur les jetons dans un bloc de code (qui pourrait être utile en soi, de toute façon).

Dans les deux cas, je proposerais que l'expansion des symboles liés aux composants natifs (c'est-à-dire implémentés dans le code Ruby) retourne une sorte de stub qui pourrait être appelé pour obtenir la fonctionnalité du module intégré, tout en étant impossible ou tout simplement peu susceptible d'être annulé. Par exemple #$(ou {$}_) pourrait retourner par exemple {builtin_dollar}, où builtin_dollarcontiendrait l'implémentation réelle de la fonction $intégrée (et #builtin_dollarou {builtin_dollar}_devrait simplement se retourner {builtin_dollar}).

Cela permettrait aux redéfinitions intégrées d'être redéfinies sans perdre l'accès à leurs fonctionnalités (voir ma suggestion précédente ), de sorte que si, disons, pour une raison quelconque , je voulais permuter la signification de $et @, je pourrais simplement le faire #$ #@ :$; :@;(ou {$}_ {@}_ :$; :@;).

Préréglage variable avec des arguments de ligne de commande

Malheureusement, il n'y a aucun caractère non affecté, mais peut-être pouvons-nous l'utiliser Apour cela?

Fonctions Ruby natives que je devrais implémenter

Ceci est le wiki communautaire; n'hésitez pas à modifier et ajouter les fonctions que vous pensez que je devrais implémenter!

Format: " nativeFunctionName( nameInMyLanguage)"

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

Profitez également des fonctionnalités APL et HQ9 +!

• Raccourcis, comme dans APL. EDIT: vient de voir la réponse "alias unicode". C'est ce que je voulais dire :)
• Autres raccourcis orientés golf, comme dans H9 +, HQ9 +, CHIQRSX9 +

Séparer clairement les éléments intégrés

par exemple, les capitales: intégrées; rendre B pour la base réalisable

Variables locales / fermetures

Une chose qui me manque vraiment dans GolfScript est la possibilité de changer temporairement la valeur d'un symbole .

En particulier, il n'y a actuellement aucun moyen de remplacer temporairement la signification d'un intégré "primitif": une fois que vous avez, par exemple, redéfini $, vous ne trierez plus jamais rien dans ce programme. (Eh bien, pas sans avoir écrit votre propre implémentation de tri, au moins.) Ce serait vraiment bien de pouvoir dire, par exemple, que dans ce bloc de code $ signifie autre chose, mais gardez toujours le sens normal ailleurs.

En relation avec ce qui précède, il serait bien de lier les symboles d'un bloc de code à leur valeur actuelle . Bien sûr, je peux écrire, dire {$-1%}:rsortet pouvoir utiliser rsortpour trier et inverser un tableau, mais cela ne fonctionne que tant que la définition de $(ou -1ou %) ne change pas, car ma rsortfonction appelle toujours le symbole global $. Ce serait bien de pouvoir dire "laisse rsortfaire ce $-1%qui se passe actuellement, même si ces symboles sont redéfinis plus tard".

En particulier, la bibliothèque standard pourrait utiliser ce type de liaison. Il est assez surprenant de constater que, par exemple, le changement nchange le comportement de puts, ou que la redéfinition !gâche complètement xor. (Là encore, une certaine prudence doit être exercée ici, car, en particulier, la possibilité de modifier le comportement des putstours s'avère être le seul moyen d'éviter d'éviter l'impression d'un retour à la ligne final dans la version actuelle de GS.)

Edit: La possibilité de reconvertir les symboles en blocs de code contribuerait grandement à la mise en œuvre de cette fonctionnalité. En particulier, la {foo}_syntaxe suggérée dans cette réponse effectuerait efficacement un niveau de liaison statique en développant tous les symboles dans un bloc de code. Combinez cela avec un combinateur de points fixes pour une liaison statique profonde, et Bob est votre oncle ...

Plus de fonctions intégrées

Faites en sorte que toutes les variables à lettre unique az et AZ remplissent une fonction générique et utile. Quelques éléments intégrés qui manquent:

• min et max: tout ou partie des 2 premières valeurs de pile, n premières valeurs de pile, sur un tableau
• valeur absolue
• somme et produit d'un tableau. pourquoi faire {+}*quand vous pouvez le faire S? Vous avez 52 fonctions avec lesquelles travailler ici!
• Manhattan distance (c. -à- x1 y1 x2 y2 --> abs(x2-x1)+abs(y2-y1). Maintenant , il faudrait être @-A@@-A+si Aest intégré en valeur absolue Accordé cela ne est venu caues de mon. Poste le plus récent mais j'ai toujours pensé que ce serait un bon moyen d'élargir golfscript: écrire ce les fonctions seraient utiles pour les avoir, les collecter et les ajouter en tant que fonctions intégrées.
• Convertissez un entier en une chaîne d'un caractère (équivalent de python chr).
• Renverser une chaîne sur la pile (actuellement {}/)
• Une version de :cela consomme ce qui est stocké. Cela ne devrait pas être «collé» aux identifiants pour être utile.
• Opérateurs pour >=,<=
• Comme quelqu'un l'a suggéré, un moyen de mettre une variable contenant un bloc sur la pile sans l'exécuter. Vous pouvez donc réduire les ifs du formulaire 1{\}{|}ifà quelque chose comme1?\?|if
• Conversion en base64 intégrée et prise en charge de zlib pour faire en sorte que les données d'intégration prennent moins de caractères
• Au-delà de base64, créez un codage base93 personnalisé (en utilisant tous les caractères imprimables qui ne sont pas le délimiteur de chaîne).
• Raccourcis pour 1$, 2$, 3$, 4$,5$
• Un opérateur pour copier les deux premiers éléments de la pile tels quels, c'est-à-dire \.@.@\

Ce serait bien si la valeur écrite ou calculée dans la dernière ligne d'une fonction était retournée automatiquement