私は、もっと多くのことができるより短いプログラムのために、改善されたGolfScriptを書くつもりです。これは挑戦ではありません。それは私がすべきことについてのフィードバックとヒントのリクエストです。（タグを参照）

^{これがコミュニティWikiかどうかはわかりません。もしそうだと思うなら、モデレーターにそれを変換するようにフラグを立ててください:)}

この言語は、GolfScriptと非常によく似ています。まだRubyで書かれています。ただし、いくつかの違いがあります。

• `文字列の区切り文字として使用します。これは一般的な文字ではないため、エスケープの必要は少なくなります。（他のキャラクターは、その機能を置き換えることができます#（詳細は後ほど））。\`バックティック\\をエスケープする、バックスラッシュをエスケープする、他のエスケープシーケンスはありません。改行が必要な場合は、文字列に実際のリテラル改行を挿入するだけです。
• RationalGolfScriptの主な欠陥の1つである任意精度の浮動小数点にRubyを使用する。
• 型を他の型に変換する機能。たとえば、ブロックを文字列に変換できます。
• 正規表現。おそらくで作成されました"..."。オペレーターもそれらに対して過負荷になります。たとえば、"\W"~{`Invalid: non-word character`}{`OK`}if。ブロックなどの変数からプッシュされると、自動的に実行されます。
• ファイルおよび日付オブジェクト。GolfScriptでは不可能だったより多くのことを行います。これらにはリテラルはありませんが、それらを初期化するための関数`file.txt`flがあります（ファイル作成関数の名前は変更される場合があります）。
• ハッシュかもしれませんが、それについてはわかりません。したほうがいい？
• さらに機能するヘルパー関数。たとえば、`http://example.com`netネットワークアクセスの場合（ここでも、net演算子の名前を変更できます）。rb文字列をRubyコードとして実行します。これらはさらに多くあります。提案を歓迎します。
• コメントはありませんので、#他のことに使用できます。コメントが必要な場合は、問題`comment here`;なく機能します。（おそらく関数#を置き換えることができ`ます）
• 関数を追加するのがはるかに簡単になるように完全に書き直されます。基本的に、コードはより読みやすくなります。（GolfScriptのソースを見ましたか？:/）
• Github上にあるため、共同で作業できます。私はMITか何かの下でそれを認可します。
• 最終的な改行がないため、チートなクインが機能します：P

そして、私はこれらを最も劇的で有用な変更だと思うので、これらを区別しています（おそらく浮動小数点を追加することを除く）：

• 多くのRuby関数が組み込まれています。例えば、shuffle（略称されてもよいsf）（以前にかかった9文字）、 tr（以前は14文字）、 sample（sm予め.,rand=）、 flatten（fl以前???）、等
• レブムのようにドロドロになります。たとえば~:a0<{0a-}aIF、~:$0<{0$-}$if（sort関数を上書きする）代わりに（文字変数名を使用して）できるようになりました。（ここからの例）。この方法では、大文字と小文字が区別されず、変数名に数字を使用できないことに注意してください。これはゴルフの言語なので、私の意見では大丈夫です：P
• デバッグが行われます。配列区切り文字、要素区切り文字などを指定するフラグ、数値出力（有理数、浮動小数点数、または整数？）、命令を1つずつステップ実行し、プログラムを実行する代わりに各トークンをトークン化して出力する機能を追加します。等

だから、私の質問は次のとおりです。改善するものは何ですか？何を追加すべきだと思いますか？

コーディングを始める前に、これに関する他のアイデアはありますか？

柔軟なI / O

現時点では、Golfscriptをインタラクティブプログラムに使用することはできません。明示的な入力のためのいくつかの関数を追加することを提案します（つまりreadline、getchar友人）。インタープリターは、実行前にプログラムがこれらを使用するかどうかを確認する必要があります。

プログラムが入力関数を呼び出さない場合、インタープリターはGolfscriptが通常行うように動作する必要があります。

インタプリタが実行時に生成された評価済みコードの入力関数を検出することは期待していませんが、それが何らかの形でそれを行うことができるなら、称賛に値します。

より短いビルトイン

それらを持たないすべての組み込みコマンドの単一文字エイリアス。baseそれがちょうどだったら私はもっともっと使うだろうB。

div-modの組み合わせ

これは、提案のいくつかよりも少しニッチですが、数論のプログラムに取り組んでいたとき、私は頻繁に自分自身が2つの整数をポップ操作たく見つけるaとb、スタックとプッシュからa/bとしますa%b。（現在、これは1$1$/@@%）です。

数字

先行0が数値の一部ではないようにレクサーを変更します。

# current behaviour
01     # -> 1

# new
01     # -> 0 1

また、_代わりに負の数を記述する必要があります。

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

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

スタック全体へのアクセス

GolfScriptはスタックベースの言語ですが、スタックの上位3つのアイテム以外のすべてへのアクセスは<integer>$、n番目のアイテムのコピーに制限されています。PostScriptのrollコマンドのようなものを用意しておくと、3つ以上の「ライブ」変数で作業しやすくなります。

理想的には、1引数バージョンと2引数バージョンがありますが、周囲に十分な名前がない場合は、1引数は1文字のものに優先されるはずです。

引数が1つの場合は、ロールするアイテムの数だけを取ります。たとえば、1 roll何もしません。2 rollに等しい\; 3 rollに等しい@; 4 rollそして、より大きな数字には既存の同等物がありません。可能な限り最も近いものは

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

（そして、それはスタック上の特定の位置、またはactive [で非整数さえも処理せず、ほぼ確実にループ内で壊れます）。

引数が2つの場合も、ロールするのにある程度の時間がかかります。a b roll2はと同等{a roll}b*です。

CJam

「改良されたGolfScript」を実装しました。これはCJamと呼ばれます-http : //sf.net/p/cjam
現在、2番目のリリース（バージョン0.6）では、ここで説明する機能のほとんどではなくとも多くを既に備えています。それらをリストしてみます：

• まだRubyで書かれている-いや、Java
• `文字列の区切り文字として使用-いいえ、ただし、エスケープが最小限の二重引用符付き文字列を使用します（\エスケープのみ\および"）
• 浮動小数点-サポートされていますが、任意の精度ではなく標準の「double」のみ
• タイプを他のタイプに変換-はい
• 正規表現-まだではありませんが、計画中です。特別な演算子で通常の文字列を使用します
• ファイルおよび日付オブジェクト-いいえ、ただし現在の日付/時刻を取得できます
• ハッシュ-それらがpython dictまたはjavaマップのようなものであると仮定すると、それらはサポートされません（将来検討される可能性があります）
• さらに多くのことを行うヘルパー関数-はい、たくさん
• `http://example.com`net - "example.com"g
• Rubyコードとして文字列を実行する-いいえ
• コメントなし-正確に、#他の何かに使用され、"comments like this";
• 関数を追加するのが簡単です-そうだと思いますが、私もバイアスがかかっています:)
• Githubで-さらに良い（私の意見では、撮影しないでください）-SourceForgeでhgを使用して
• MITでライセンスされています-はい
• 最終改行なし-右
• シャッフル- mr
• tr- er
• サンプル-未完了、 _,mr=
• 平坦化-完了していませんが、おそらく簡単に達成できます
• マッシュ-いいえ、しかし識別子は分離する必要はありません

• デバッグ-スタックトレースのみ、およびedスタックを表示するための演算子

• 柔軟なI / O-はい、ただし明示的な入力のみ

• 短いビルトイン-はい、b=ベース、z= zip
• 先行する0を分けます-いいえ、ただし定義済みの変数を使用できます
• 明確に--はい、しかしではないと_。1 2-3-> 1 2 -3; 1 2m3->-1 3
• スタックのロール/回転-いいえ
• 配列セット- t
• divmod- md
• レクサーを変更する（識別子用）-はい、詳細は以下
• デカルト積-まったく同じではありませんが、はい、 m*
• ユニコード演算子-いいえ
• 単一文字の識別子-定義済みの演算子には1文字または2文字があり、変数は単一文字の大文字です。それらはすべて、レクサー/パーサーを混乱させることなく連結できます。
• ブロック上の演算子-いいえ
• 安定したソート-はい
• シンボルをコードブロックに戻します-いいえ、ただし後で追加できます
• 現在の日付/時刻- et
• コマンドライン引数- ea
• ビルトインを明確に分離-はい、ただし大文字は変数です。組み込みは、小文字および特殊文字で始まります
• minおよびmax-はい、現在2つの値のみ：e<、e>
• 絶対値- z（GolfScript absには欠けていないがあります）
• 配列の和と積- :+、:*
• マンハッタン距離-いいえ
• chr- c（文字列ではなく文字に変換します）
• 文字列をスタックにこぼします-CJam文字列は数字ではなく文字で構成されています。キャラクターをこぼすにはまだ{}/
• :保存されているものを消費するバージョン-いいえ
• 事業者にとって>=、<=-いや、使用<!、>!
• base64およびzlib-いいえ
• 1 $、2 $、3 $、4 $、5 $のショートカット-いいえ
• 上位2つのスタックアイテムをコピーします-計画済み。今のところ使用1$1$
• ローカル変数-いいえ
• HQ9 +の機能-いいえ、ありがとう

CJamにはさらに多くの機能があります。https： //sourceforge.net/p/cjam/wiki/Operators/をご覧ください

Change the lexer

GolfScript's lexer treats a Ruby identifier (anything which matches the regex [_a-zA-Z][_a-zA-Z0-9]*) as a single token. If it instead treated [a-zA-Z]+ as a token that would free up _ to be a built-in and would allow an alpha variable to be followed by a literal integer without separating whitespace.

Unicode aliases

Multiple-character commands could have unicode aliases. This would save on the score when the score is counted in characters and not in bytes.

Stable sort

The $ builtin on blocks should perform a stable sort.

Array set operator

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

Any built-in we can make available for that?

Single-character identifiers

It's not like a code golf solution is going to have too many variables. And it would save on spaces.

% as builtin for product

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

Regex support

The lack of regex support has always struck me as odd in a language designed for golfing. It would be great to have

• <string> <string> <string> y (aka tr, using Perl's one-char alias for it)
• <string> <string> <string> s (substitute)
• <string> <string> <block> s (substitute with callback)
• <string> <string> m (match)

Builtins for current date/time

It is currently very quirky to get date/time using Ruby evals.

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