Métodos y 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]

Nota

Los mapas pueden almacenar closures como campos. Si un campo del mapa tiene el mismo nombre que un método integrado, el método del prototipo tiene prioridad. La closure se usa como fallback solo cuando no existe un método integrado con ese nombre.

---

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

Tipo	Método	Args	Devuelve
Int	.abs()	0	Int
	.min(otro)	1	Int
	.max(otro)	1	Int
	.pow(exp)	1	Int
	.to_field()	0	Field
	.to_string()	0	String
String	.len()	0	Int
	.starts_with(prefijo)	1	Bool
	.ends_with(sufijo)	1	Bool
	.contains(substr)	1	Bool
	.split(delim)	1	List
	.trim()	0	String
	.replace(buscar, reempl)	2	String
	.to_upper()	0	String
	.to_lower()	0	String
	.chars()	0	List
	.index_of(substr)	1	Int
	.substring(inicio, fin)	2	String
	.repeat(n)	1	String
	.to_string()	0	String
List	.len()	0	Int
	.push(elem)	1	nil
	.pop()	0	valor
	.map(fn)	1	List
	.filter(fn)	1	List
	.reduce(init, fn)	2	valor
	.for_each(fn)	1	nil
	.find(fn)	1	valor
	.any(fn)	1	Bool
	.all(fn)	1	Bool
	.sort(fn)	1	List
	.flat_map(fn)	1	List
	.zip(otra)	1	List
Map	.len()	0	Int
	.keys()	0	List
	.values()	0	List
	.entries()	0	List
	.contains_key(clave)	1	Bool
	.get(clave, default)	2	valor
	.set(clave, valor)	2	nil
	.remove(clave)	1	valor
Field	.to_int()	0	Int
	.to_string()	0	String
BigInt	.to_bits()	0	List
	.bit_and(otro)	1	BigInt
	.bit_or(otro)	1	BigInt
	.bit_xor(otro)	1	BigInt
	.bit_not()	0	BigInt
	.bit_shl(n)	1	BigInt
	.bit_shr(n)	1	BigInt

Namespaces Estáticos

Namespace	Miembro	Valor
Int::MAX		576460752303423487 (2^59 - 1)
Int::MIN		-576460752303423488 (-2^59)
Field::ZERO		Elemento de campo 0
Field::ONE		Elemento de campo 1
Field::ORDER		Módulo BN254 Fr (string)
BigInt::from_bits		Constructor from_bits(bits, ancho)