Cheddar es un lenguaje de programación de alto nivel, funcional y orientado a objetos creado por nuestro usuario Downgoat diseñado para hacer que la programación sea más fácil, más rápida y más intuitiva.

¿Qué consejos generales tienes para jugar al golf en Cheddar? Estoy buscando ideas que se puedan aplicar a problemas de código de golf y que también sean al menos algo específicas para Cheddar (por ejemplo, "Eliminar espacios en blanco innecesarios" no es una respuesta).

Usar propiedades funcionalizadas

Si alguna vez usa solo una propiedad en una función:

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

Puede usar propiedades funcionalizadas para guardar algunos bytes:

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

Puede hacer referencia a la variable en la propiedad funcionalizada con $0.

Use el operador de cadena para secuencias de cadena

Estoy hablando del @"operador que hace cosas diferentes, todas las cuales tratan con cadenas. Esto tiene muchos usos, pero este es uno de mis usos favoritos:

Mira esto:

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

no es tan útil pero lo contrario es:

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

Esto es especialmente útil para generar el alfabeto :

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

Curry

No, no el curry rojo (¿en qué otro curry estarías pensando?). Me refiero a este tipo de curry:

a->b->

Si tiene una función tomando dos argumentos. Es más corto curry que no:

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

Nota: Esto solo es más corto cuando tiene exactamente dos argumentos.

Usar argumentos predeterminados

Declarar variables Cheddar puede ser un desperdicio de bytes:

->{var a=b+1}

Afortunadamente, puedes (ab) usar los valores predeterminados de la función para crear variables:

b=a+1->b

Aquí hay algunos ejemplos de usos:

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

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

Usar operadores y enlaces funcionalizados

Esto es muy simple. Si tienes algo como:

i->1+i

o cualquier operación similar. Puede acortar el uso de operadores funcionalizados + enlaces:

1&(+)

Usa el operador de mapeo

Los =>mapas de LHS a RHS, debido a su precedencia, esto también significa que puede usarlo con rangos y usarlo varias veces:

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

Adicionalmente:

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