Manual de Bosque. Typed Strings. Invocaciones flexibles Operaciones de datos algebraicos a granel. Características destacadas
Typed Strings
Las Typed Strings proporcionan un mecanismo novedoso para elevar la estructura conocida sobre el contenido de una cadena al tipo de una manera que sea significativa para los humanos y que pueda ser utilizada por el verificador de tipos. Esto permite código como el siguiente:
function foo(zip: String[Zipcode], name: String) {...}
var zc: String[Zipcode] = ...;
var user: String = ...;
foo(user, zc) //Type error String not convertible to String[Zipcode]
foo(zc, user) //ok
Invocaciones flexibles
Bosque proporciona argumentos con nombre junto con los operadores de descanso y propagación. Se pueden usar para realizar una manipulación de datos simple y potente como parte de las invocaciones y las operaciones del constructor.
function nsum(d: Int, ...args: List[Int]): Int {
return args.sum(default=d);
}
function np(p1: Int, p2: Int): {x: Int, y: Int} {
return @{x=p1, y=p2};
}
//calls with explicit arguments
var x = nsum(0, 1, 2, 3); //returns 6
var a = np(1, 2); //returns @{x=1, y=2}
var b = np(p2=2, 1); //also returns @{x=1, y=2}
//calls with spread arguments
var t = @[1, 2, 3];
var p = nsum(0, ...t); //returns 6 -- same as explicit call
var r = @{p1=1, p2=2};
var q = np(...r); //returns @{x=1, y=2} -- same as explicit call
Operaciones de datos algebraicos a granel
Las operaciones algebraicas masivas en Bosque comienzan con el soporte para lecturas masivas y actualizaciones de valores de datos. Considere el caso común de tener una estructura con 3 campos donde 2 de ellos necesitan actualizarse. En la mayoría de los idiomas, esto debería hacerse campo por campo. Sin embargo, con las operaciones de datos en masa es posible realizar la actualización como una operación atómica (a diferencia de un estilo imperativo) y sin extraer y copiar manualmente los campos (como en un estilo funcional).
var x = @{f=1, g=2, h=3};
x<~(f=-1, g=-2); //@{f=-1, @g=-2, h=3}
Además de eliminar las oportunidades de olvidar o confundir un campo, estos operadores ayudan a enfocar el código en la intención general, en lugar de ocultarse en los pasos individuales, y permiten que un desarrollador realice un razonamiento algebraico en las operaciones de la estructura de datos. Bosque proporciona varios tipos de estas operaciones algebraicas para varios tipos de datos, tuplas, registros y tipos nominales, y para varias operaciones que incluyen proyección, actualización múltiple y combinación.
var l = @[7, 8, 9];
var r = @{f=7, g=8};
l@[0, 2]; //@[7, 9]
l<+(@[5, 6]); //@[7, 8, 9, 5, 6]
l#[Int, Int]; //@[7, 8]
r@{f, h}; //@{f=7, h=none}
r<~(f=5, h=1); //@{f=5, g=8, h=1}
r<+(@{f=5, h=1}); //@{f=5, g=8, h=1}