Ich plane, ein verbessertes GolfScript für noch kürzere Programme zu schreiben, die mehr können. Dies ist keine Herausforderung. Es ist eine Bitte um Feedback und Tipps, was ich tun soll. (siehe tags)

^{Ich bin mir nicht sicher, ob dies Community Wiki sein soll. Wenn Sie so denken, markieren Sie es einfach, damit ein Moderator es konvertiert :)}

Diese Sprache wird GolfScript sehr ähnlich sein. Es ist immer noch in Ruby geschrieben. Es gibt jedoch einige Unterschiede:

• Wird `als Zeichenkettenbegrenzer verwendet, da es sich um ein ungewöhnliches Zeichen handelt, sodass weniger Escapezeichen erforderlich sind. (Ein anderes Zeichen kann seine Funktion ersetzen, wie #(dazu später mehr)). \`einem Backtick \\zu entkommen, einem Backslash zu entkommen, und es gibt keine anderen Escape-Sequenzen. Wenn Sie eine neue Zeile benötigen, kleben Sie einfach eine tatsächliche wörtliche Zeile in die Zeichenfolge.
• Die Verwendung von Ruby's Rationalfür Gleitkommazahlen mit willkürlicher Genauigkeit ist einer der Hauptfehler von GolfScript.
• Die Möglichkeit, Typen in andere Typen zu konvertieren. Sie können beispielsweise einen Block in eine Zeichenfolge konvertieren.
• Reguläre Ausdrücke. Wahrscheinlich erstellt mit "...". Die Operatoren werden auch für sie überlastet. Zum Beispiel "\W"~{`Invalid: non-word character`}{`OK`}if. Wird automatisch ausgeführt, wenn von einer Variablen wie Blöcken gedrückt wird.
• Datei- und Datumsobjekte, um mehr Dinge zu tun, die in GolfScript nicht möglich waren. Diese haben keine Literale, aber Funktionen zum Initialisieren, wie zB `file.txt`fl(der Name der Funktion zum Erstellen von Dateien kann sich ändern).
• Haschs vielleicht, aber da bin ich mir nicht sicher. Sollte ich?
• Der Helfer kann noch mehr. Zum Beispiel `http://example.com`netfür den Netzwerkzugriff (erneut kann der netBetreiber umbenannt werden). rbum einen String als Ruby-Code auszuführen. Es wird noch viel mehr davon geben; Vorschläge willkommen.
• Keine Kommentare, so dass #für etwas anderes verwendet werden kann. Wenn Sie einen Kommentar wünschen, `comment here`;wird gut funktionieren. (Vielleicht #kann `'s die Funktion ersetzen )
• Es wird komplett neu geschrieben, so dass das Hinzufügen von Funktionen viel einfacher wird. Grundsätzlich ist der Code besser lesbar. (Haben Sie die GolfScript-Quelle gesehen? :/)
• Es wird auf Github sein, damit gemeinsam daran gearbeitet werden kann. Ich werde es unter MIT lizenzieren oder so.
• Keine abschließende Newline, daher funktionieren betrügerische Quines: P

Und ich setze diese Punkte auseinander, weil ich denke, dass sie die drastischsten und hilfreichsten Änderungen sind (außer vielleicht das Hinzufügen von Gleitkommazahlen):

• Es werden viele Ruby-Funktionen eingebaut. Zum Beispiel shuffle(was abgekürzt werden kann sf) (früher 9 Zeichen ), tr(früher 14 Zeichen ), sample( smfrüher .,rand=), flatten( flfrüher ???) usw.
• Es wird wie Rebmu gemixt. Zum Beispiel können Sie jetzt ~:a0<{0a-}aIF(unter Verwendung eines Buchstabenvariablennamens) anstatt ~:$0<{0$-}$if(die Sortierfunktion zu überschreiben). (Beispiel von hier ). Beachten Sie, dass auf diese Weise die Groß- und Kleinschreibung nicht berücksichtigt wird und in Variablennamen keine Zahlen zulässig sind. Dies ist meiner Meinung nach in Ordnung, da es eine Golfsprache ist: P
• Es wird ein Debugging haben. Ich werde die Möglichkeit hinzufügen, ein Flag bereitzustellen, das Array-Begrenzer, Element-Begrenzer usw. angibt, die Ausgabe von Zahlen (rational, float oder int?), Schrittweise Anweisungen durchläuft, jedes Token tokenisiert und ausgibt, anstatt das Programm auszuführen. etc.

Meine Frage lautet also: Was gibt es zu verbessern? Was denkst du sollte ich hinzufügen?

Irgendwelche anderen Ideen dafür, bevor ich anfange, es zu codieren?

Flexibles I / O

Golfscript kann derzeit nicht für interaktive Programme verwendet werden. Ich schlage vor , einige Funktionen für explizite Eingabe hinzugefügt werden ( das heißt readline,getchar und Freunde). Der Interpreter sollte prüfen, ob das Programm diese verwendet, bevor es ausgeführt wird.

Wenn das Programm keine Eingabefunktionen aufruft, sollte sich der Interpreter wie bei Golfscript verhalten.

Ich würde nicht erwarten, dass der Interpreter Eingabefunktionen in ausgewertetem Code erkennt, der zur Laufzeit generiert wird, aber wenn er das irgendwie kann, ein dickes Lob.

Kürzere Einbauten

Einzelzeichen-Aliase für alle eingebauten Befehle, die diese nicht haben. Ich würde baseviel mehr verwenden, wenn es nur so wäre B.

Kombinierter Div-Mod

Das ist ein bisschen mehr Nische als einige der Vorschläge, aber wenn sie auf zahlentheoretische Programmen arbeiten selbst finde ich häufig eine Operation zu wollen , die zwei ganze Zahlen erscheinen aund baus dem Stapel und Stösse a/bund a%b. (Derzeit ist dies 1$1$/@@%).

Zahlen

Ändern Sie das Lexer so, dass führende 0 nicht Teil einer Zahl ist:

# current behaviour
01     # -> 1

# new
01     # -> 0 1

_Stattdessen sollten auch negative Zahlen geschrieben werden:

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

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

Zugriff auf den gesamten Stapel

GolfScript ist eine stapelbasierte Sprache, aber der Zugriff auf alle Elemente außer den drei obersten auf dem Stapel ist auf <integer>$das Kopieren des n-ten Elements beschränkt. Es wäre nützlich, so etwas wie den PostScript- rollBefehl zu haben, damit es einfacher ist, mit mehr als drei "Live" -Variablen zu arbeiten.

Idealerweise gibt es eine Ein-Argument- und eine Zwei-Argument-Version, aber wenn nicht genügend Namen in der Nähe sind, sollte das Ein-Argument eine Ein-Zeichen-Version bevorzugen.

Die Ein-Argument-Eins nimmt nur die Anzahl der zu würfelnden Gegenstände. ZB 1 rollmacht nichts; 2 rollist gleichbedeutend mit \; 3 rollist gleichbedeutend mit @; 4 rollund für höhere Nummern gibt es kein vorhandenes Äquivalent; das nächstmögliche ist so etwas wie

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

(und das behandelt nicht einmal Nicht-Ganzzahlen an bestimmten Positionen des Stapels oder aktiv [und bricht mit ziemlicher Sicherheit auch innerhalb von Schleifen).

Die Zwei-Argumente-Variante benötigt ebenfalls einen Betrag, um zu würfeln. a b roll2ist äquivalent zu {a roll}b*.

CJam

Ich habe "ein verbessertes GolfScript" implementiert und es heißt CJam - http://sf.net/p/cjam. In
der zweiten Version (Version 0.6) enthält es bereits viele, wenn nicht die meisten der hier diskutierten Funktionen. Ich werde versuchen, sie aufzulisten:

• noch in Ruby - Nope, Java geschrieben
• Verwenden `als Zeichenkettenbegrenzer - nein, aber es werden Zeichenketten in doppelten Anführungszeichen mit minimalem Escape-Zeichen verwendet ( \nur Escape- Zeichen \und ")
• Gleitkomma - unterstützt, aber nur Standard "double", keine willkürliche Genauigkeit
• Typen in andere Typen konvertieren - ja
• reguläre Ausdrücke - noch nicht, aber geplant; verwendet reguläre Zeichenfolgen mit speziellen Operatoren
• Datei- und Datumsobjekte - nein, kann aber das aktuelle Datum / die aktuelle Uhrzeit abrufen
• Hashes - vorausgesetzt, diese sind wie Python-Diktate oder Java-Maps, dann werden sie nicht unterstützt (wird möglicherweise in Zukunft berücksichtigt)
• Hilfsfunktionen, um noch mehr zu erreichen - ja, sehr viel
• `http://example.com`net - "example.com"g
• führe einen string als ruby ​​code aus - nope
• keine Kommentare - genau, #für etwas anderes verwendet,"comments like this";
• einfachere Funktionen hinzuzufügen - ich denke schon, aber ich bin auch voreingenommen :)
• auf Github - noch besser (meiner Meinung nach nicht fotografieren) - auf SourceForge mit hg
• lizenziert unter MIT - ja
• kein abschließender Zeilenumbruch - richtig
• Mischen - mr
• tr - er
• Probe - nicht fertig, _,mr=
• Abflachen - nicht getan, aber wahrscheinlich leichter zu erreichen
• Nein, aber die Bezeichner müssen nicht getrennt werden

• Debugging - Nur Stapel-Traces und edOperator zum Anzeigen des Stapels

• flexible I / O - ja, aber nur explizite Eingabe

• kürzere Einbauten - ja, b= Sockel, z= Reißverschluss
• separate führende 0 - nein, kann aber vordefinierte Variablen verwenden
• klarstellen -- ja, aber nicht mit _; 1 2-3-> 1 2 -3; 1 2m3->-1 3
• den Stapel rollen / drehen - nein
• Array-Set - t
• divmod - md
• Ändern Sie das Lexer (für Bezeichner) - ja, mehr unten
• kartesisches Produkt - nicht genau das gleiche, aber ja, m*
• Unicode-Operatoren - Nr
• Einzelzeichen-IDs - Vordefinierte Operatoren haben 1 oder 2 Zeichen, und Variablen sind Großbuchstaben mit Einzelzeichen. Sie können alle verkettet werden, ohne den Lexer / Parser zu verwirren
• Bediener auf Blöcken - Nr
• stabile Sorte - ja
• Symbole wieder in Codeblöcke umwandeln - nein, kann aber später hinzugefügt werden
• aktuelles Datum / Uhrzeit - et
• Befehlszeilenargumente - ea
• Eingebaute Elemente klar voneinander trennen - ja, aber Großbuchstaben sind Variablen; Built-Ins sind oder beginnen mit Kleinbuchstaben und Sonderzeichen
• min und max - ja, die derzeit nur für 2 Werte: e<,e>
• absoluter Wert - z(GolfScript hatabs nicht gefehlt)
• Summe und Produkt eines Arrays - :+,:*
• Manhattan Entfernung - nein
• chr - c(konvertiert in ein Zeichen, keine Zeichenkette)
• Verschütten Sie eine Zeichenfolge auf den Stapel - CJam-Zeichenfolgen bestehen aus Zeichen und nicht aus Zahlen. um die Charaktere zu verschütten ist es still{}/
• eine Version von : davon verbraucht, was gespeichert ist - nein
• Operatoren für >=, <=- nein, verwenden <!,>!
• base64 und zlib - nope
• Abkürzungen für 1 $, 2 $, 3 $, 4 $, 5 $ - nein
• Kopieren Sie die beiden obersten Stapelelemente - geplant; für jetzt verwenden1$1$
• lokale Variablen - nein
• HQ9 + Funktionen - nein, danke

CJam hat viel mehr Funktionen, siehe https://sourceforge.net/p/cjam/wiki/Operators/

Ändern Sie den Lexer

Der GolfScript-Lexer behandelt einen Ruby-Bezeichner (alles, was mit dem regulären Ausdruck übereinstimmt [_a-zA-Z][_a-zA-Z0-9]*) als einen einzigen Token. Wenn es stattdessen [a-zA-Z]+als Token behandelt wird , entsteht ein integriertes Token, auf das _eine Alpha-Variable von einer Literal-Ganzzahl gefolgt werden kann, ohne Leerzeichen zu trennen.

Unicode-Aliase

Befehle mit mehreren Zeichen können Unicode-Aliase enthalten. Dies würde die Punktzahl einsparen, wenn die Punktzahl in Zeichen und nicht in Bytes gezählt wird.

Stabile Sorte

Die $eingebauten Blöcke sollten eine stabile Sortierung ausführen.

Array-Set-Operator

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

Können wir dafür ein eingebautes Gerät zur Verfügung stellen?

Einzelzeichen-IDs

Es ist nicht so, dass eine Code-Golf-Lösung zu viele Variablen enthalten würde. Und es würde Platz sparen.

% als eingebaut für Produkt

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

Regex-Unterstützung

Der Mangel an Regex-Unterstützung hat mich in einer für das Golfen konzipierten Sprache immer als merkwürdig empfunden. Es wäre toll zu haben

• <string> <string> <string> y(auch bekannt trals Perls One-Char-Alias)
• <string> <string> <string> s (Ersatz)
• <string> <string> <block> s (durch Rückruf ersetzen)
• <string> <string> m (Spiel)

Builtins für aktuelles Datum / Uhrzeit

Es ist derzeit sehr eigenartig, Datum und Uhrzeit mithilfe von Ruby-Auswertungen abzurufen.

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

Make |, & and ^ built-ins do something useful on blocks

E.g. <array/string> <block> | can be used as index function

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

Any ideas for <array/string> <block> & or <array/string> <block> ^?

A way to turn symbols back into code blocks

Currently, we can bind code blocks to symbols with :, but there's no way to reverse the process: executing a symbol bound to a code block just executes the block.

I can see a couple of ways to implement this:

1. add new syntax, e.g. #foo to push the value of foo to the stack, even if it's a code block, or

2. add an operator to expand every symbol in a code block, so that (using _ as the new operator), e.g. {2*}:dbl; {dbl dbl}_ would produce {2* 2*}.

I can see advantages to both methods. The latter could substitute for the former, at the cost of two extra chars ({foo}_ instead of #foo), but I can see some potential applications for the former syntax where those two chars would be prohibitive (e.g. using array #func % instead of array {func} %).

Meanwhile, the former syntax could be used to replace the latter if there was a convenient way to somehow iterate over the tokens in a code block (which could be useful on its own, anyway).

In either case, I'd propose that expanding symbols that are bound to native built-ins (i.e. implemented in Ruby code) should return some kind of stub that could be called to obtain the functionality of the built-in, while being either impossible or just unlikely to be overridden. For example #$ (or {$}_) could return e.g. {builtin_dollar}, where builtin_dollar would contain the actual implementation of the $ built-in (and #builtin_dollar or {builtin_dollar}_ should just return {builtin_dollar} itself).

This would allow built-ins to be redefined without losing access to their functionality (see my earlier suggestion), so that if I, say, for some reason wanted to swap the meanings of $ and @, I could just do #$ #@ :$; :@; (or {$}_ {@}_ :$; :@;).

Variable preset with command line args

Unfortunately, there isn't any char left unassigned, but maybe we can use A for that?

Native Ruby functions that I should implement

This is Community Wiki; feel free to edit and add the functions you think I should implement!

Format: "nativeFunctionName (nameInMyLanguage)"

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

Take features from APL and HQ9+ too!

• Shortcuts, like in APL. EDIT: just saw the answer "unicode aliases". That's what I meant :)
• Other golf-oriented shortcuts, like in H9+, HQ9+, CHIQRSX9+

Clearly separating built-ins

e.g. capitals : built-ins ; making B for base feasable

Local variables / closures

One thing I really miss in GolfScript is the ability to temporarily change the value of a symbol.

In particular, there's currently no way to temporarily override the meaning of a "primitive" built-in: once you, say, redefine $, you're never going to sort anything in that program again. (Well, not without writing your own sort implementation, at least.) It would be really nice to be able to say, for example, that in this code block $ means something else, but still keep the normal meaning elsewhere.

Related to the above, it would be nice to bind symbols in a code block to their current value. Sure, I can write, say, {$-1%}:rsort and be able to use rsort to sort and reverse an array, but that works only as long as the definition of $ (or -1 or %) doesn't change, since my rsort function is still calling the global symbol $. It would be nice to be able to say "let rsort do what $-1% currently does, even if those symbols are later redefined."

In particular, the standard library could use this kind of binding. It's kind of surprising to realize that, say, changing n changes the behavior of puts, or that redefining ! completely messes up xor. (Then again, some caution should be exercised here, since, in particular, the ability to change the behavior of puts turns out to be turns out to be the only way to avoid printing a final newline in the current version of GS.)

Edit: Being able to turn symbols back into code blocks would go a long way towards implementing this functionality. In particular, the {foo}_ syntax suggested in that answer would effectively perform one level of static binding by expanding all symbols in a code block. Combine that with a fixpoint combinator for deep static binding, and Bob's your uncle...

More built-in functions

Make all the single-letter variables a-z and A-Z perform some generic, useful function. Some built-ins that are lacking:

• min and max: all or some of top 2 stack values, top n stack values, over an array
• absolute value
• sum and product of an array. why do {+}* when you can do S? You have 52 functions to work with here!
• Manhattan distance (i.e. x1 y1 x2 y2 --> abs(x2-x1)+abs(y2-y1). Now it'd have to be @-A@@-A+ if A is a built-in absolute value. Granted this only came up caues of my most recent post but I always figured that'd be a good way to expand golfscript: write down what functions would be handy to have, collect them, and add them as built-ins.
• Convert an integer to a one-character string (equivalent of python's chr).
• Spill a string onto the stack (currently {}/)
• A version of : that consumes what is stored. This would have to not get 'stuck' to identifiers to be useful.
• Operators for >=, <=
• As someone suggested, a way to put a variable containing a block onto the stack without executing it. So you could reduce ifs of the form 1{\}{|}if to something like 1?\?|if
• Built-in base64 conversion and zlib support to make embedding data take less characters
• Beyond base64, make a custom base93 encoding (using all printable characters that aren't the string delimiter).
• Shortcuts for 1$, 2$, 3$, 4$, 5$
• An operator to copy the top two stack items as they are, i.e. \.@.@\

It'd be nice if the value written or computed in the last line of a function was automatically returned