Lo básico de Gosu

El siguiente programa Gosu emite el texto "Hello World" a la consola usando la función integrada
de impresión:

print ("Hola Mundo")

Gosu utiliza el tipo de Java java.util.String como su tipo String nativo para manipular textos. Puede
crear literales de cadena en línea al igual que en Java. Además, Gosu apoya plantillas nativas en
línea, lo que simplifica la sustitución de texto común patrones de codificación.

Para declarar una variable en la forma más sencilla, utilice la sentencia var seguido del nombre de
la variable. Típico código Gosu también inicializa la variable utilizando el signo igual seguido de
cualquier expresión Gosu:

var x = 10
var y = x + x

A pesar de las apariencias en este ejemplo, Gosu es de tipado estático. Todas las variables tienen
un tipo en tiempo de compilación que Gosu hace cumplir en tiempo de compilación, a pesar de
que en este ejemplo no hay una declaración de tipo explícita.
En este ejemplo, Gosu asigna automáticamente estas variables del tipo int. Gosu infiere el tipo int
de las expresiones de la parte derecha de los signos Igual en líneas que declaran la variable.
Esta característica del lenguaje se llama inferencia de tipos.

La inferencia de tipos ayuda a mantener el código Gosu limpio y simple, sobre todo en
comparación con otros lenguajes de programación de tipo estático. Esto hace que el código típico
Gosu sea fácil de leer, pero conserva el poder y la seguridad de tipos estáticos.
Por ejemplo, tomemos el patrón común de declaración de una variable y creando instancias de un
objeto. En Gosu, esto se parece a:

var c = new MyVeryLongClassName ()

Esto es equivalente al siguiente código de Java:

MyVeryLongClassName c = new MyVeryLongClassName ();

Como puede ver, la versión Gosu es más fácil de leer y más concisa.
Gosu también apoya las declaraciones de tipo explícitas de variables durante la declaración,
añadiendo un carácter de dos puntos y un nombre de tipo. El nombre de tipo podría ser un
lenguaje primitivo, un nombre de clase o nombre de la interfaz.
Por ejemplo:

var x: int = 3

Se requieren declaraciones de tipo explícitas si no está inicializando la variable en la misma

sentencia que la declaración de variables. También se requiere que las declaraciones de tipo
explícitos para todas las declaraciones de variables de clase.

Nota:
A partir de los ejemplos anteriores, usted podría notar otra diferencia entre Gosu y Java: no hay
punto y coma u otros caracteres de final de línea. Los puntos y comas son innecesarios en casi
todos los casos, y el estilo estándar es omitirlos.
Control de flujo

Gosu tiene todas las estructuras de flujo de control comunes, incluyendo mejoras en las versiones
de Java.
Gosu tiene el familiar if, else if y else:

if (myRecord.Open and myRecord.MyChildList.length> 10) {

// algo de lógica
} Else if (no myRecord.Open) {
// un poco más lógica
} Else {
// aún más lógica
}

Gosu permite que las palabras inglesas más legibles para los operadores booleanos: and, or, y not.
Opcionalmente puede utilizar las versiones simbólicas de Java (&&, ||, y !). Esto hace que el
código de control de flujo típico sea más fácil de entender.
El for en Gosu es similar a la sintaxis de Java 1.5:

for (ad en AddressList) {

print (ad.Id)
}

Esto funciona con matrices o cualquier objeto Iterable. A pesar de las apariencias, la variable esta
fuertemente tipada. Gosu infiere al tipo basado en el tipo de la variable iterada. En el ejemplo
anterior, si AddressList tiene Tipo Address[], entonces ad Tipo Address.
Si la variable AddressList es null, la sentencia for se omite por completo, y Gosu no genera ningún
error. En contraste, Java lanza una excepción de puntero null si el objeto iterable es nulo.

Si quieres un índice dentro del bucle, utilice la siguiente sintaxis para acceder al índice de base
cero:

for (a in AddressList index i) {

print (a.Id + "tiene índice" + i)
}

Gosu tiene soporte nativo para intervalos, que son secuencias de valores del mismo tipo entre un
par dado de valores de punto final. Por ejemplo, el conjunto de números enteros que comienzan
con 0 y terminan con 10 es un intervalo entero. Si es un intervalo cerrado (contiene el arranque y
valores finales), que contiene los valores 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10.
La sintaxis abreviada de Gosu para esto es 0..10. Los intervalos son particularmente útiles para
escribir breve y fácil de entender para los bucles:

for (i en 1..10) {
print (i)
}

Puede especificar opcionalmente un intervalo abierto en uno o ambos extremos del intervalo, es
decir, no incluir los valores especificados. La sintaxis Gosu 1 | .. | 10 significa un intervalo abierto
en ambos lados, lo que significa que los valores van del 2 al 9.

Los intervalos no se necesitan para representar números. Los intervalos pueden ser una variedad
de tipos, incluyendo números, fechas u otras abstracciones tales como nombres. Gosu incluye la
sintaxis abreviada incorporado (los dos períodos, que se muestra anteriormente) para los
intervalos de fechas y tipos de números comunes. Puede así al agregar tipos de intervalo
personalizado que soportan secuencias comparables iterables. Siempre y cuando su tipo de
intervalo implementa las interfaces requeridos, podrá utilizar sus nuevos intervalos en las
declaraciones de bucle:

for (i in new ColorInterval ("rojo", "azul")) {

print (i)
}

Gosu no tiene un equivalente directo de propósito general de las tres partes de Java para la
declaración:

for (i = 1; i <20; ++ i)

Sin embargo, en la práctica el uso de intervalos hace uso más típico de este patrón innecesario, y
se puede utilizar un bucle while Gosu duplicar este patrón.
Para utilizar con intervalos para los bucles, debe haber un intervalo iterativo.
Se puede optar por hacer intervalos de encargo no iterativos si se requieren. Son principalmente
útiles para las matemáticas y el trabajo teórico. Por ejemplo, representar valores no computables
como el número infinito de números reales entre otros dos números reales.

La sentencia switch Gosu puede probar cualquier tipo de objeto, con un caso especial por defecto
al final:

var x = "b"
switch( x ) {
case "a":
print("a")
break
case "b":
print("b")
break
default:
print("c")
}

En Gosu, debe colocar una sentencia break al final de cada caso para pasar a la final de la
sentencia switch.
De lo contrario, cae a través de Gosu al caso siguiente en la serie. Por ejemplo, para el ejemplo
anterior si se quita las sentencias break, el código imprime ambas "b" y "c". Esto es igual que en
Java, aunque algunos idiomas no requieren la declaración break para evitar caer al siguiente caso.
Bloques

Gosu soporta funciones en línea que puede pasar alrededor como objetos. Algunos lenguajes
llaman a estos cierres o expresiones lambda. En Gosu, estos son llamados bloques.

Para definir un bloque

1. Comenzar con el carácter \

2. Añadir opcionalmente una lista de argumentos como pares nombre/tipo separados por un
carácter de dos puntos.
3. Añadir los caracteres -> , que marcan el comienzo del cuerpo del bloque
4. Finalmente, añadir ya sea un lista de sentencias rodeado por llaves: { y }, o una expresión Gosu.

El siguiente bloque multiplica un número con sí mismo, que se conoce como la cuadratura un
número:

var cuadrado = \ x: Number x * x / / sin necesidad de llaves aquí (que es una expresión, no declaraciones)
var myResult = square (10) // llamar el bloque

El valor de myResult en este ejemplo es 100.

Los bloques son increíblemente útiles como parámetros del método, lo que permite la aplicación
del método de generalizar alguna tarea o algoritmo, pero permitir a las personas que llaman para
inyectar código para personalizarlo. Por ejemplo, Gosu añade muchos métodos útiles a las
colecciones de Java clases que tienen un bloque como parámetro. Ese bloque podría devolver una
expresión (por ejemplo, una condición para probar cada elemento en contra) o podría representar
una acción a realizar en cada artículo.
Por ejemplo, el siguiente código Gosu hace una lista de cadenas, ordena que por la longitud de
cada string, luego itera a través de la lista de resultados para imprimir cada elemento de orden:

var strings = {"aa", "ddddd", "c"}

strings.sortBy (\ str -> str.length) each (\ str -> {print (str)})

Bloque Especial de acceso directo para Interfaces de Un Método

Si la clase interna anónima implementa una interfaz y la interfaz tiene exactamente un método,
entonces usted puede utilizar un bloque Gosu para implementar la interfaz como un bloque. Esta
es una alternativa al uso de una clase anónima explícito. Esto es cierto para interfaces
implementadas originalmente en cualquiera Gosu o Java.

Por ejemplo:

_callbackHandler.execute (\ -> { / * sus declaraciones Gosu aquí * /})