Métodos y Namespaces Estáticos

Referencia de los 50 métodos de tipo y miembros de namespaces estáticos.

Desde beta.13, la mayoría de operaciones sobre valores usan sintaxis de métodos: valor.metodo(args). Los métodos se resuelven en tiempo de ejecución basándose en el tag del tipo. Cada tipo tiene su propio conjunto de métodos.

Achronyme también proporciona namespaces estáticos usando la sintaxis Tipo::MIEMBRO para constantes y constructores a nivel de tipo.

Sintaxis de Métodos

// Llamada a método
let items = [3, 1, 2]
let sorted = items.sort(fn(a, b) { a - b })

// Encadenamiento
let result = [1, 2, 3, 4, 5]
    .filter(fn(n) { n > 2 })
    .map(fn(n) { n * 10 })
// result: [30, 40, 50]

Int

6 métodos sobre valores enteros.

.abs()

Devuelve el valor absoluto.

let x = -42
assert(x.abs() == 42)

.min(otro)

Devuelve el menor de dos enteros.

assert(3.min(7) == 3)

.max(otro)

Devuelve el mayor de dos enteros.

assert(3.max(7) == 7)

.pow(exp)

Exponenciación entera. El exponente debe ser no negativo.

assert(2.pow(10) == 1024)

.to_field()

Convierte el entero a un elemento de campo BN254.

let f = 42.to_field()
assert(typeof(f) == "Field")

.to_string()

Devuelve la representación en string.

assert(42.to_string() == "42")

Estáticos: Int::MAX, Int::MIN

Límites del entero con signo de 60 bits.

print(Int::MAX)  // 576460752303423487 (2^59 - 1)
print(Int::MIN)  // -576460752303423488 (-2^59)

String

14 métodos sobre valores de cadena.

.len()

Devuelve el número de caracteres.

assert("hello".len() == 5)

.starts_with(prefijo)

Devuelve true si la cadena comienza con el prefijo dado.

assert("hello".starts_with("hel"))

.ends_with(sufijo)

Devuelve true si la cadena termina con el sufijo dado.

assert("hello".ends_with("llo"))

.contains(substr)

Devuelve true si la cadena contiene la subcadena.

assert("hello world".contains("world"))

.split(delimitador)

Divide la cadena por el delimitador dado. Devuelve una lista de cadenas.

assert("a,b,c".split(",") == ["a", "b", "c"])

.trim()

Elimina espacios en blanco al inicio y al final.

assert("  hello  ".trim() == "hello")

.replace(buscar, reemplazo)

Reemplaza todas las apariciones de buscar con reemplazo.

assert("aabbcc".replace("bb", "XX") == "aaXXcc")

.to_upper()

Convierte todos los caracteres a mayúsculas.

assert("hello".to_upper() == "HELLO")

.to_lower()

Convierte todos los caracteres a minúsculas.

assert("HELLO".to_lower() == "hello")

.chars()

Divide en una lista de caracteres individuales.

assert("abc".chars() == ["a", "b", "c"])

.index_of(substr)

Devuelve el índice de la primera aparición. Devuelve -1 si no se encuentra.

assert("hello world".index_of("world") == 6)
assert("hello".index_of("xyz") == -1)

.substring(inicio, fin)

Extrae una subcadena desde la posición inicio hasta fin (exclusivo). Los índices se ajustan a los límites.

assert("hello".substring(1, 4) == "ell")

.repeat(n)

Repite la cadena n veces. Tamaño máximo: 10 MB.

assert("ab".repeat(3) == "ababab")

.to_string()

Devuelve la cadena misma (identidad).

assert("hi".to_string() == "hi")

List

13 métodos sobre valores de lista.

.len()

Devuelve el número de elementos.

assert([1, 2, 3].len() == 3)

.push(elemento)

Agrega un elemento al final. Modifica la lista en su lugar. Devuelve nil.

mut items = [1, 2]
items.push(3)
assert(items.len() == 3)

.pop()

Elimina y devuelve el último elemento. Devuelve nil si está vacía.

mut items = [1, 2, 3]
assert(items.pop() == 3)
assert(items.len() == 2)

.map(fn)

Devuelve una nueva lista con fn(elem) aplicado a cada elemento.

let doble = [1, 2, 3].map(fn(n) { n * 2 })
assert(doble == [2, 4, 6])

.filter(fn)

Devuelve una nueva lista con solo los elementos donde fn(elem) es verdadero.

let pares = [1, 2, 3, 4].filter(fn(n) { n % 2 == 0 })
assert(pares == [2, 4])

.reduce(inicial, fn)

Pliega la lista en un solo valor: acc = fn(acc, elem) para cada elemento.

let suma = [1, 2, 3].reduce(0, fn(acc, n) { acc + n })
assert(suma == 6)

.for_each(fn)

Llama fn(elem) para cada elemento (para efectos secundarios). Devuelve nil.

[1, 2, 3].for_each(fn(n) { print(n) })

.find(fn)

Devuelve el primer elemento donde fn(elem) es verdadero, o nil si ninguno coincide.

let encontrado = [1, 2, 3, 4].find(fn(n) { n > 2 })
assert(encontrado == 3)

.any(fn)

Devuelve true si fn(elem) es verdadero para algún elemento. Cortocircuita.

assert([1, 2, 3].any(fn(n) { n == 2 }))

.all(fn)

Devuelve true si fn(elem) es verdadero para todos los elementos. Cortocircuita.

assert([1, 2, 3].all(fn(n) { n > 0 }))

.sort(fn)

Devuelve una nueva lista ordenada. El comparador fn(a, b) debe devolver negativo si a < b, cero si iguales, positivo si a > b.

let ordenado = [3, 1, 2].sort(fn(a, b) { a - b })
assert(ordenado == [1, 2, 3])

.flat_map(fn)

Como .map(), pero aplana un nivel de listas anidadas.

let result = [1, 2, 3].flat_map(fn(n) { [n, n * 10] })
assert(result == [1, 10, 2, 20, 3, 30])

.zip(otra)

Devuelve una lista de pares [a, b], truncada a la lista más corta.

let pares = [1, 2, 3].zip([10, 20, 30])
assert(pares == [[1, 10], [2, 20], [3, 30]])

Map

8 métodos sobre valores de mapa.

.len()

Devuelve el número de pares clave-valor.

let m = {name: "Alice", age: 30}
assert(m.len() == 2)

.keys()

Devuelve una lista de todas las claves.

let m = {name: "Alice", age: 30}
let k = m.keys()
assert(k.len() == 2)

.values()

Devuelve una lista de todos los valores.

let m = {a: 1, b: 2, c: 3}
let v = m.values()
assert(v.len() == 3)

.entries()

Devuelve una lista de pares [clave, valor].

let m = {x: 10, y: 20}
let e = m.entries()
// e contiene [["x", 10], ["y", 20]]
assert(e.len() == 2)

.contains_key(clave)

Devuelve true si el mapa contiene la clave dada.

let m = {name: "Alice"}
assert(m.contains_key("name"))
assert(!m.contains_key("age"))

.get(clave, default)

Devuelve el valor para clave, o default si la clave no existe.

let m = {name: "Alice"}
assert(m.get("name", "?") == "Alice")
assert(m.get("age", 0) == 0)

.set(clave, valor)

Establece o actualiza un par clave-valor. Modifica el mapa en su lugar. Devuelve nil.

mut m = {}
m.set("name", "Alice")
m.set("age", 30)
assert(m.len() == 2)
assert(m.name == "Alice")

.remove(clave)

Elimina una clave y devuelve su valor. Devuelve nil si la clave no existe.

mut m = {name: "Alice", age: 30}
let eliminado = m.remove("age")
assert(eliminado == 30)
assert(m.len() == 1)

Field

2 métodos sobre elementos de campo BN254.

.to_int()

Convierte el elemento de campo a un entero. El valor debe caber en 64 bits.

let f = 0p42
assert(f.to_int() == 42)

.to_string()

Devuelve la representación decimal en string.

let f = 0p42
assert(f.to_string() == "42")

Estáticos: Field::ZERO, Field::ONE, Field::ORDER

Constantes de campo para BN254 Fr.

let z = Field::ZERO   // 0p0
let o = Field::ONE     // 0p1
let q = Field::ORDER   // "21888242871839275222246405745257275088548364400416034343698204186575808495617"

BigInt

7 métodos sobre valores BigInt256 y BigInt512.

.to_bits()

Convierte a una lista de enteros 0/1 en orden LSB primero. La longitud es 256 o 512 dependiendo del ancho.

let bits = bigint256(42).to_bits()
// bits[0] = 0, bits[1] = 1, bits[2] = 0, bits[3] = 1, bits[4] = 0, bits[5] = 1

.bit_and(otro)

AND a nivel de bits. Ambos operandos deben tener el mismo ancho.

let result = bigint256("0xFF").bit_and(bigint256("0x0F"))
assert(result == bigint256("0x0F"))

.bit_or(otro)

OR a nivel de bits. Ambos operandos deben tener el mismo ancho.

let result = bigint256("0xF0").bit_or(bigint256("0x0F"))
assert(result == bigint256("0xFF"))

.bit_xor(otro)

XOR a nivel de bits. Ambos operandos deben tener el mismo ancho.

let result = bigint256("0xFF").bit_xor(bigint256("0x0F"))
assert(result == bigint256("0xF0"))

.bit_not()

NOT a nivel de bits (invierte todos los bits).

let x = bigint256(0).bit_not()  // todos los bits activados

.bit_shl(n)

Desplaza a la izquierda n bits. Error si algún bit se desborda.

assert(bigint256(1).bit_shl(8) == bigint256(256))

.bit_shr(n)

Desplaza a la derecha n bits. Los bits desplazados se descartan.

assert(bigint256(256).bit_shr(8) == bigint256(1))

Estático: BigInt::from_bits

Alias para la función global from_bits.

let val = BigInt::from_bits(bigint256(42).to_bits(), 256)
assert(val == bigint256(42))

Tabla Resumen

Métodos por Tipo

Namespaces Estáticos