Cheddar è un linguaggio di programmazione di alto livello, funzionale + orientato agli oggetti, creato dal nostro utente Downgoat progettato per rendere la programmazione più facile, più veloce e più intuitiva.

Quali consigli generali hai per giocare a golf a Cheddar? Sto cercando idee che possano essere applicate a problemi di code-golf e che siano anche in qualche modo specifiche per Cheddar (es. "Rimuovere spazi bianchi non necessari". Non è una risposta).

Usa proprietà funzionanti

Se mai usi solo una proprietà in una funzione:

A->A.long.property(n).foo.bar

È possibile utilizzare le proprietà funzionalizzate per salvare alcuni byte:

@.long.property(n).foo.bar

È possibile fare riferimento alla variabile nella proprietà funzionalizzata con $0.

Utilizzare l'operatore String per le sequenze di stringhe

Sto parlando @"dell'operatore che fa cose diverse, tutte legate alle stringhe. Questo ha parecchi usi ma questo è uno dei miei usi preferiti:

Guarda questo:

@" [103, 111, 97, 116, 115] === "goats"

non molto utile, ma il contrario è:

@"'goats' === [103, 111, 97, 116, 115]
'goats'.bytes // compare the above too

Ciò è particolarmente utile per generare l'alfabeto :

65@"90    // Uppercase Alphabet
97@"122   // Lowercase Alphabet
65@"90+97@"122 // Both cases
String.letters // Compare 97@"122 to this

Curry

No, non curry rosso (a quale altro curry penseresti ¬_¬). Intendo questo tipo di curry:

a->b->

Se hai una funzione che accetta due argomenti. È più corto al curry che non:

(a,b)->
a->b->

Nota: questo è solo più breve quando hai esattamente due argomenti.

Usa argomenti predefiniti

Dichiarare le variabili Cheddar può essere piuttosto il byte-waster:

->{var a=b+1}

fortunatamente, puoi (ab) usare i valori predefiniti della funzione per creare variabili:

b=a+1->b

Ecco alcuni esempi di usi:

let f= (a,b=a+1)->b
f(5) // 6

let f= a=Math.rand()->a
f() // 0.8757450950797647

Utilizzare operatori funzionanti e collegamento

Questo è semplice. Se hai qualcosa come:

i->1+i

o qualsiasi operazione simile. Puoi abbreviare usando operatori funzionalizzati + bonding:

1&(+)

Usa l'operatore di mappatura

Le =>mappe da LHS a RHS, a causa della sua precedenza, questo significa anche che puoi usarlo con intervalli e usarlo più volte:

a=>f
(a).map(f)

Inoltre:

a=>f=>g           // This is equivilant to...
(a).map(f).map(g) // this