Pyth est en développement continu, ce qui signifie que de nouvelles fonctionnalités sont ajoutées en permanence.

Je veux faire de Pyth une meilleure langue, donc je voudrais savoir quelles fonctionnalités les gens recherchent.

C'est l'endroit où vous avez les idées de publication pour améliorer Pyth.

Dans votre réponse, veuillez indiquer:

• Ce que vous aimeriez voir changé / ajouté.

• Un exemple d'utilisation de la modification.

Je commenterai si je prévois de mettre en œuvre la suggestion.

Veuillez vérifier si l'idée que vous souhaitez suggérer a déjà été suggérée. Upvote les idées que vous aimeriez mettre en œuvre.

Suggestions mises en œuvre:

• Chaîne Eval en Pyth , as.v

• Plus d'opérations Regex

• Appliquer tant que.W

• Boucles imbriquées et autres Lambdas (ils utilisent le même mécanisme en dessous)

• Aplatir les listes imbriquées comme.n

C'était sur le sujet selon cette méta-question quand j'ai posté la question, ce n'est plus clair.

Boucles imbriquées

Si vous souhaitez imbriquer des forboucles, vous devez actuellement gaspiller un octet pour l'utiliser à l' F<var><seq>intérieur de a V<seq>ou vice versa. J'aimerais avoir la même chose qu'avec lambdas, où la variable utilisée pour la boucle changerait lors de l'imbrication des boucles.

Turt

Équivalent Pyth des graphiques de tortues , selon import turtle.

Importation plus facile de modules

Jusqu'à présent, chaque fois que je l'ai utilisé, $cela a été quelque chose comme:

$from <module> import <function> as <pyth-function-with-same-arity>$
for example:
$from unicodedata import name as neg$

Il pourrait y avoir une nouvelle fonction qui résume cela par exemple .$:

.$"unicodedata""name""neg"
.$"unicodedata name neg"

Ou en utilisant la nouvelle syntaxe comme celle _Mqui peut ne pas être facile / possible à faire:

_$unicodedata name$

De plus, une fonction avec chaque zone peut recevoir un nom de macro à une seule lettre afin que ces appels soient plus courts (sauf pour l' _$option).

En train de dormir

Cela a causé des problèmes ici , et @ mbomb007 a suggéré de le mettre comme une amélioration de Pyth . Fondamentalement, en ce moment, afin de dormir pendant le nombre de secondes donné, je dois faire quelque chose comme:

Q$__import__('time').sleep(Q)$

Ce qui est ennuyeux et aussi diable.

Plus de lambdas

C'est vraiment l'idée de FryAmTheEggman , mais je la poste pour la diffuser .

Parfois, je trouve que l'utilisation de deux lambdas à un argument différents raccourcirait le code, tout en devant utiliser un lambda à deux arguments pour un ne le ferait pas.

Ce serait bien d'avoir L, Met les amis redéfinissent une fonction différente à chaque utilisation; par exemple, ce code:

L*b2L*b3y5'5

pourrait compiler pour:

@memoized
def subsets(b):
 return times(b,2)
@memoized
def read_file(b):
 return times(b,3)
imp_print(subsets(5))
imp_print(read_file(5))

Le choix exact des fonctions pourrait bien sûr être modifié.

Tableaux multidimensionnels améliorés

L'utilisation de tableaux multidimensionnels est assez difficile à faire actuellement. Par exemple, le code C A[B][C][D]se traduirait @@@ABCDen Pyth. Quelque chose comme ça @A[BCD)serait beaucoup plus agréable (mais pas plus court ici). Il en va de même pour X; A[B][C][D] = Eest actuellement X@@ABCDE, quand il pourrait l'être XA[BCD)E.

Quelques idées mineures

• Différence absolue, c.-à-d abs(val1 - val2). Actuellement c'est .a-<val1><val2>.
• min/ maxpour les valeurs. Actuellement, c'est hS,<val1><val2>/ eS,<val1><val2>ou la même chose avec plus de valeurs. ( hS<seq>/ eS<seq>pour les séquences est assez court.)

Pas une fonctionnalité Pyth, mais néanmoins ...

Modulariser le code Pyth

Cela n'affecte que Pyth sous le capot. Certaines parties de l'implémentation Pyth sont assez compliquées. Beaucoup de variables globales et d'autres choses hacky.

J'ai été vraiment frustré il y a quelques jours, lorsque j'ai essayé d'utiliser quelques fonctions de l'implémentation Pyth (comme exécuter une chaîne de commandes Pyth) à partir d'un autre script Python.

Quelque chose comme ce qui suit serait bien:

from pyth import execute_pyth
print(execute_pyth(code='sQ', input='[1, 2, 3]'))

Eh bien, je suppose que ce n'est qu'un appel à l'aide pour Pyth5.

Éléments uniques

Pyth n'a actuellement aucun moyen d'obtenir des éléments uniques d'une séquence. Vous pouvez tester s'il est unique, mais vous ne pouvez pas obtenir les éléments réellement uniques. Actuellement, le moyen le plus court est :

{.-Q{Q

6 octets! Comparer à K, où l' obtention des éléments uniques est une opération sur un octet: =x.

Peut .}- être que ça fonctionnerait ici?