Sto pensando di scrivere un GolfScript migliorato per programmi ancora più brevi che possono fare più cose. Questa non è una sfida; è una richiesta di feedback e suggerimenti su cosa dovrei fare. (vedi tag)

^{Non sono sicuro se questo dovrebbe essere Community Wiki. Se la pensi così, basta contrassegnare un moderatore per convertirlo :)}

Questo linguaggio sarà molto simile a GolfScript. È ancora scritto in Ruby. Tuttavia, ha alcune differenze:

• Usando `come delimitatore di stringa, perché è un carattere non comune, quindi sarà necessario meno escape. (Un altro personaggio può sostituire la sua funzione, come #(ne parleremo più avanti)). \`per sfuggire a un backtick, \\per sfuggire a una backslash e non ci sono altre sequenze di escape. Se hai bisogno di una nuova riga, inserisci semplicemente una nuova riga letterale nella stringa.
• Utilizzo di Ruby Rationalper la precisione arbitraria in virgola mobile, uno dei principali difetti di GolfScript.
• La possibilità di convertire i tipi in altri tipi. Ad esempio, è possibile convertire un blocco in una stringa.
• Espressioni regolari. Probabilmente creato con "...". Gli operatori saranno sovraccaricati anche per loro. Ad esempio "\W"~{`Invalid: non-word character`}{`OK`}if,. Si eseguirà automaticamente quando viene spinto da una variabile, come i blocchi.
• Oggetti File e Date, per fare più cose impossibili in GolfScript. Questi non avranno valori letterali, ma avranno funzioni per inizializzarli, come `file.txt`fl(il nome della funzione di creazione dei file può cambiare).
• Hash forse, ma non ne sono sicuro. Dovrei?
• Funzioni di supporto per fare ancora di più. Ad esempio, `http://example.com`netper l'accesso alla rete (di nuovo, l' netoperatore può essere rinominato). rbper eseguire una stringa come codice Ruby. Ce ne saranno molti altri; suggerimenti benvenuti.
• Nessun commento, in modo che #possa essere utilizzato per qualcos'altro. Se vuoi un commento, `comment here`;funzionerà bene. (Forse #può sostituire `la funzione)
• Sarà completamente riscritto in modo che sia molto più semplice aggiungere funzioni. Fondamentalmente, il codice sarà più leggibile. (Hai visto l'origine GolfScript? :/)
• Sarà su Github in modo da poter lavorare in modo collaborativo. Lo autorizzerò in base al MIT o qualcosa del genere.
• Nessuna nuova riga finale, quindi i quines economici funzionano: P

E li distinguo perché penso che siano i cambiamenti più drastici e utili (tranne forse l'aggiunta di virgola mobile):

• Avrà molte funzioni di Ruby integrate. Ad esempio, shuffle(che può essere abbreviato in sf) (in precedenza aveva assunto 9 caratteri ), tr(in precedenza 14 caratteri ), sample( sm, in precedenza .,rand=), flatten( fl, in precedenza ???), ecc.
• Sarà schiacciato, come Rebmu. Ad esempio, ora è possibile eseguire ~:a0<{0a-}aIF(utilizzando un nome di variabile lettera) anziché ~:$0<{0$-}$if(sovrascrivere la funzione di ordinamento). (esempio da qui ). Si noti che in questo modo non fa distinzione tra maiuscole e minuscole e i numeri non sono consentiti nei nomi delle variabili. Questo va bene secondo me dal momento che è un linguaggio da golf: P
• Avrà il debug. Aggiungerò la possibilità di fornire un flag specificando i delimitatori di array, i delimitatori di elementi, ecc., L'output numerico (razionale, float o int?), Esaminando le istruzioni una alla volta, tokenizzando e producendo ciascun token invece di eseguire il programma, eccetera.

Quindi, la mia domanda è: cosa c'è da migliorare? Cosa pensi che dovrei aggiungere?

Altre idee per questo, prima di iniziare a codificarlo?

I / O flessibile

Attualmente Golfscript non può essere utilizzato per programmi interattivi. Propongo alcune funzioni per l'input esplicito da aggiungere (ad esempio readline, getchare amici). L'interprete dovrebbe vedere se il programma li utilizza prima di eseguirlo.

Se il programma non chiama alcuna funzione di input, l'interprete dovrebbe comportarsi normalmente come Golfscript.

Non mi aspetterei che l'interprete rilevi le funzioni di input nel codice di valutazione generato in fase di esecuzione, ma se in qualche modo può farlo, complimenti.

Incorporati più corti

Alias ​​a carattere singolo per tutti i comandi integrati che non li hanno. Userei basemolto di più se fosse giusto B.

Div-mod combinato

Questa è un po 'più di nicchia di alcuni dei suggerimenti, ma quando lavoro su programmi di teoria dei numeri mi trovo spesso a desiderare un'operazione che salta due numeri interi ae bdallo stack e spinge a/be a%b. (Al momento questo è 1$1$/@@%).

Numeri

Cambia il lexer in modo tale che lo 0 iniziale non faccia parte di un numero:

# current behaviour
01     # -> 1

# new
01     # -> 0 1

Anche i numeri negativi dovrebbero essere scritti con _:

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

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

Accesso all'intero stack

GolfScript è un linguaggio basato sullo stack, ma l'accesso a tutti tranne i primi tre elementi nello stack è limitato <integer>$alla copia dell'ennesimo elemento. Sarebbe utile avere qualcosa come il rollcomando di PostScript in modo che sia più facile lavorare con più di tre variabili "live".

Idealmente ci sarebbero versioni one-arg e two-arg, ma se non ci fossero abbastanza nomi in giro, allora one-arg dovrebbe avere la preferenza per una a un carattere.

Il one-arg richiede solo il numero di oggetti da lanciare. Ad esempio 1 roll, non fa nulla; 2 rollè equivalente a \; 3 rollè equivalente a @; 4 rolle per numeri più alti non esiste un equivalente esistente; il più vicino possibile è qualcosa di simile

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

(e che non gestisce nemmeno i numeri interi in determinate posizioni nello stack, o attivi [, e quasi certamente si rompe anche all'interno dei loop).

Anche il two-arg richiede un importo per essere lanciato; a b roll2è equivalente a {a roll}b*.

CJam

Ho implementato "un GolfScript migliorato" e si chiama CJam - http://sf.net/p/cjam
Ora alla seconda versione (versione 0.6) ha già molte se non la maggior parte delle funzionalità discusse qui. Proverò ad elencarli:

• ancora scritto in Ruby - no, java
• usando `come delimitatore di stringa - no, ma utilizza stringhe tra virgolette con escape minimo ( \solo escape \e ")
• virgola mobile - supportato, ma solo "doppio" standard, precisione non arbitraria
• converti i tipi in altri tipi - sì
• espressioni regolari - non ancora, ma pianificate; utilizzerà stringhe regolari con operatori speciali
• Oggetti file e data: no, ma possono ottenere la data / ora correnti
• hash - supponendo che siano come dicts python o mappe java, quindi non sono supportati (potrebbe prendere in considerazione in futuro)
• funzioni di supporto per fare ancora di più - sì, molto
• `http://example.com`net - "example.com"g
• esegue una stringa come codice Ruby - no
• nessun commento - esattamente, #usato per qualcos'altro,"comments like this";
• più facile aggiungere funzioni - penso di sì, ma sono anche di parte :)
• su Github - ancora meglio (secondo me, per favore, non sparare) - su SourceForge, usando hg
• concesso in licenza in base al MIT - sì
• nessuna nuova riga finale - giusto
• shuffle - mr
• tr - er
• campione - non fatto, _,mr=
• appiattire: non fatto, ma probabilmente più facile da ottenere
• pestato - no, ma gli identificatori non devono essere separati

• debug: solo tracce dello stack e edoperatore per mostrare lo stack

• I / O flessibile: sì, ma solo input esplicito

• built-in più brevi - sì, b= base, z= zip
• separare 0 iniziale - no, ma può utilizzare variabili predefinite
• non ambiguo -: sì, ma non con _; 1 2-3-> 1 2 -3; 1 2m3->-1 3
• rotola / ruota la pila - no
• set di array - t
• divmod - md
• cambia il lexer (per identificatori) - sì, più sotto
• prodotto cartesiano - non esattamente lo stesso, ma sì, m*
• operatori unicode - no
• identificatori a carattere singolo - gli operatori predefiniti hanno 1 o 2 caratteri e le variabili sono lettere maiuscole a carattere singolo; possono essere tutti concatenati senza confondere il lexer / parser
• operatori su blocchi - n
• ordinamento stabile - sì
• trasforma i simboli in blocchi di codice - no, ma possono essere aggiunti in un secondo momento
• data / ora correnti - et
• riga di comando args - ea
• separare chiaramente gli incorporati - sì, ma i capitali sono variabili; i built-in sono o iniziano con caratteri minuscoli e speciali
• min e max - sì, attualmente solo per 2 valori: e<,e>
• valore assoluto - z(GolfScript ha abs, non manca)
• somma e prodotto di un array - :+,:*
• Distanza di Manhattan - no
• chr - c(converte in un carattere, non in una stringa)
• rovescia una stringa nello stack - le stringhe CJam sono fatte di caratteri, non di numeri; per rovesciare i personaggi è ancora{}/
• una versione :che consuma ciò che è memorizzato - no
• operatori per >=, <=- no, uso <!,>!
• base64 e zlib - no
• scorciatoie per 1 $, 2 $, 3 $, 4 $, 5 $ - no
• copia i primi due oggetti dello stack - pianificato; per ora usare1$1$
• variabili locali - no
• Funzionalità HQ9 + - no, grazie

CJam ha molte più funzioni, controlla https://sourceforge.net/p/cjam/wiki/Operators/

Cambia il lexer

Il lexer di GolfScript tratta un identificatore Ruby (tutto ciò che corrisponde al regex [_a-zA-Z][_a-zA-Z0-9]*) come un singolo token. Se invece [a-zA-Z]+venisse trattato come un token che si libererebbe _come un built-in e consentirebbe a una variabile alfa di essere seguita da un numero intero letterale senza separare gli spazi bianchi.

Alias ​​Unicode

I comandi a più caratteri potrebbero avere alias unicode. Ciò risparmierebbe sul punteggio quando il punteggio viene contato in caratteri e non in byte.

Ordinamento stabile

I $blocchi incorporati dovrebbero eseguire un ordinamento stabile.

Operatore del set di array

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

Qualche built-in che possiamo rendere disponibile per quello?

Identificatori a carattere singolo

Non è come se una soluzione di code golf avesse troppe variabili. E risparmierebbe spazio.

% come incorporato per il prodotto

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

Supporto Regex

La mancanza di supporto regex mi ha sempre reso strano in un linguaggio progettato per il golf. Sarebbe bello avere

• <string> <string> <string> y(aka tr, usando l' alias di un carattere di Perl per questo)
• <string> <string> <string> s (sostituto)
• <string> <string> <block> s (sostituire con callback)
• <string> <string> m (incontro)

Incorporati per data / ora correnti

Attualmente è molto bizzarro ottenere data / ora usando Ruby evals.

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

Make |, & e ^ built-in fanno qualcosa di utile sui blocchi

Ad esempio, <array/string> <block> |può essere utilizzato come funzione di indice

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

Qualche idea per <array/string> <block> &o <array/string> <block> ^?

Un modo per trasformare i simboli in blocchi di codice

Attualmente, possiamo associare blocchi di codice a simboli con :, ma non c'è modo di invertire il processo: l'esecuzione di un simbolo associato a un blocco di codice esegue semplicemente il blocco.

Vedo un paio di modi per implementare questo:

1. aggiungere una nuova sintassi, ad esempio #fooper spingere il valore foonello stack, anche se si tratta di un blocco di codice, oppure

2. aggiungere un operatore per espandere tutti i simboli in un blocco di codice, in modo che (usando _come nuovo operatore), ad esempio, {2*}:dbl; {dbl dbl}_si produrrebbe {2* 2*}.

Vedo vantaggi per entrambi i metodi. Il secondo potrebbe sostituire il primo, al costo di due caratteri aggiuntivi ( {foo}_anziché #foo), ma posso vedere alcune potenziali applicazioni per la prima sintassi in cui quei due caratteri sarebbero proibitivi (ad esempio, utilizzare array #func %invece di array {func} %).

Nel frattempo, la prima sintassi potrebbe essere utilizzata per sostituire la seconda se esistesse un modo conveniente per iterare in qualche modo sui token in un blocco di codice (che potrebbe essere utile da solo, comunque).

In entrambi i casi, proporrei che i simboli in espansione associati ai built-in nativi (ovvero implementati nel codice Ruby) dovrebbero restituire un tipo di stub che potrebbe essere chiamato per ottenere la funzionalità del built-in, pur essendo impossibile o è improbabile che venga sovrascritto. Ad esempio #$(o {$}_) potrebbe restituire ad esempio {builtin_dollar}, dove builtin_dollarconterrebbe l'implementazione effettiva del $built-in (e #builtin_dollaro {builtin_dollar}_dovrebbe semplicemente restituire {builtin_dollar}se stesso).

Ciò consentirebbe di ridefinire gli built-in senza perdere l'accesso alla loro funzionalità (vedere il mio suggerimento precedente ), in modo che se, per esempio, volessi scambiare i significati di $e @, potrei semplicemente fare #$ #@ :$; :@;(o {$}_ {@}_ :$; :@;).

Preset variabile con arg della riga di comando

Sfortunatamente, non è rimasto alcun carattere non assegnato, ma forse possiamo usarlo A?

Funzioni native di Ruby che dovrei implementare

Questo è Wiki della comunità; sentiti libero di modificare e aggiungere le funzioni che pensi dovrei implementare!

Formato: " nativeFunctionName( nameInMyLanguage)"

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

Prendi anche le funzionalità di APL e HQ9 +!

• Scorciatoie, come in APL. EDIT: appena visto la risposta "alias Unicode". Ecco cosa intendevo :)
• Altre scorciatoie per il golf, come in H9 +, HQ9 +, CHIQRSX9 +

Separazione chiara degli incorporati

ad esempio maiuscole: incorporati; rendendo fattibile B per la base

Variabili / chiusure locali

Una cosa che mi manca davvero in GolfScript è la possibilità di modificare temporaneamente il valore di un simbolo .

In particolare, al momento non c'è modo di sovrascrivere temporaneamente il significato di un "primitivo" incorporato: una volta che, diciamo, ridefinisci $, non riordinerai mai più nulla in quel programma. (Beh, non senza scrivere la propria implementazione del proprio ordinamento, almeno.) Sarebbe davvero bello poter dire, ad esempio, che in questo blocco di codice $ significa qualcos'altro, ma mantenere il significato normale altrove.

In relazione a quanto sopra, sarebbe bello associare i simboli in un blocco di codice al loro valore corrente . Certo, posso scrivere, dire {$-1%}:rsorted essere in grado di utilizzare rsortper ordinare e invertire un array, ma funziona solo finché la definizione di $(o -1o %) non cambia, poiché la mia rsortfunzione continua a chiamare il simbolo globale $. Sarebbe bello poter dire "lascia rsortfare quello $-1%che fa attualmente, anche se quei simboli vengono successivamente ridefiniti".

In particolare, la libreria standard potrebbe utilizzare questo tipo di rilegatura. È un po 'sorprendente rendersi conto che, per esempio, cambiando ncambia il comportamento putso che la ridefinizione !incasina completamente xor. (Ancora una volta, si dovrebbe prestare attenzione qui, poiché, in particolare, la possibilità di modificare il comportamento di putsrisulta essere l'unico modo per evitare di stampare una nuova riga finale nell'attuale versione di GS.)

Modifica: Essere in grado di trasformare i simboli in blocchi di codice significherebbe molto per implementare questa funzionalità. In particolare, la {foo}_sintassi suggerita in quella risposta avrebbe effettivamente eseguito un livello di associazione statica espandendo tutti i simboli in un blocco di codice. Combina questo con un combinatore di punti fissi per un'associazione statica profonda e Bob è tuo zio ...

Altre funzioni integrate

Fai in modo che tutte le variabili a lettera singola az e AZ eseguano una funzione generica e utile. Alcuni built-in che mancano:

• min e max: tutti o alcuni dei primi 2 valori dello stack, i primi n valori dello stack, su un array
• valore assoluto
• somma e prodotto di un array. perché {+}*quando puoi farlo S? Hai 52 funzioni con cui lavorare qui!
• La distanza di Manhattan (cioè x1 y1 x2 y2 --> abs(x2-x1)+abs(y2-y1)ora dovrebbe essere @-A@@-A+se Aè un valore assoluto incorporato. Concesso questo è venuto fuori solo dai suggerimenti del mio post più recente, ma ho sempre pensato che sarebbe stato un buon modo per espandere il golfscript: scrivi cosa sarebbe utile avere funzioni, raccoglierle e aggiungerle come incorporate.
• Converti un numero intero in una stringa di un carattere (equivalente di Python chr).
• Versa una stringa nello stack (attualmente {}/)
• Una versione di :ciò consuma ciò che viene archiviato. Ciò non dovrebbe essere "bloccato" agli identificatori per essere utile.
• Operatori per >=,<=
• Come qualcuno ha suggerito, un modo per mettere una variabile contenente un blocco nello stack senza eseguirlo. Quindi potresti ridurre ifs del modulo 1{\}{|}ifa qualcosa del genere1?\?|if
• Conversione base64 integrata e supporto zlib per rendere i dati di incorporamento richiedono meno caratteri
• Oltre base64, crea una codifica base93 personalizzata (utilizzando tutti i caratteri stampabili che non sono il delimitatore di stringhe).
• Tasti di scelta rapida per 1$, 2$, 3$, 4$,5$
• Un operatore per copiare i primi due oggetti dello stack così come sono, ad es \.@.@\

Sarebbe bello se il valore scritto o calcolato nell'ultima riga di una funzione fosse restituito automaticamente