Manual del Lenguaje de programacion Bosque

microsoft

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}

Semrush sigue a tu competencia


Fecha actualización el 2019-05-06. Fecha publicación el 2019-05-06. Categoria: microsoft Autor: Oscar olg Mapa del sitio Fuente: github Version movil