Manual de Lince

escribir(a_numero("3.5") * 2)
escribir(a_texto(42) + "!")
escribir("{a_logico(0)} {a_logico("hola")}")

para cada numero n en rango(1, 10, 3) { escribir(n) }

sea dobles = mapear([1, 2, 3], funcion(val numero x): numero { devolver x * 2 })
sea pares = filtrar(rango(10), funcion(val numero x): logico { devolver x % 2 == 0 })
sea suma = reducir([1, 2, 3, 4], 0, funcion(val numero a, val numero x): numero { devolver a + x })
escribir("{dobles} {pares} {suma}")

sea nombre = "Ana"
fijo PI = 3.14159

nombre = "Blanca"
escribir(nombre)
escribir(PI)

sea puntos = 10
puntos += 5
puntos *= 2
escribir(puntos)

sea nombre = "Lin"
nombre += "ce"
escribir(nombre)

sea vidas = {"Ana": 3, "Luis": 3}
vidas["Luis"] -= 1
escribir(vidas)

sea marcador = [3, 3]
marcador[1]--
marcador[0]++
escribir(marcador)

sea contador = 1
contador = 2
escribir(contador)

intentar {
    sea contador = 3
} capturar (error e) {
    escribir(e.mensaje)
}

sea visible = "fuera"

funcion dentro(): texto {
    sea visible = "dentro"
    devolver visible
}

escribir(dentro())
escribir(visible)

sea lista notas = [9, 7, 10]
sea diccionario ficha = {"nombre": "Ana"}

funcion presentar(val texto quien, val numero anios): texto {
    devolver quien + " tiene " + anios + " años"
}

escribir(presentar(ficha["nombre"], notas.longitud()))

sea [ancho, alto] = [320, 180]
escribir(ancho * alto)

sea enemigo = {"vida": 50, "nombre": "orco", "fuerza": 7}
sea {nombre, vida} = enemigo
escribir("{nombre} con {vida} de vida")

sea a = 1
sea b = 2
[a, b] = [b, a]
escribir("{a} {b}")

sea nota = 7

si nota >= 9 {
    escribir("sobresaliente")
} sino si nota >= 5 {
    escribir("aprobado")
} sino {
    escribir("suspenso")
}

si nota > 5 y no (nota == 10) {
    escribir("entre 6 y 9")
}

sea x = 3
sea y = 8
si x > 0 y y > 0 {
    y = y - 1
    escribir("arriba a la derecha, en ({x}, {y})")
}

sea velocidad = -4
sea lado = si velocidad < 0 { "izquierda" } sino { "derecha" }
escribir(lado)

funcion nota(val numero n): texto {
    devolver si n >= 9 { "sobresaliente" } sino si n >= 5 { "aprobado" } sino { "suspenso" }
}
escribir(nota(7))

sea puntos = 1
escribir("{puntos} {si puntos == 1 { "punto" } sino { "puntos" }}")

para (i = 0; i < 3; i++) {
    escribir("para " + i)
}

sea n = 0
mientras n < 2 {
    escribir("mientras " + n)
    n = n + 1
}

sea m = 0
hacer {
    escribir("hacer " + m)
    m = m + 1
} mientras (m < 2)

para cada numero x en [10, 20] {
    escribir("cada " + x)
}

sea enemigos = [{"vida": 0}, {"vida": 5}, {"vida": 8}, {"vida": 2}]

para cada diccionario e en enemigos {
    si e["vida"] == 0 { continuar }     # los muertos no cuentan
    escribir("vivo con " + e["vida"])
    si e["vida"] > 6 {
        escribir("¡uno fuerte! dejo de mirar")
        romper
    }
}

para (i = 0; i < 20; i += 5) {
    escribir(i)
}

sea animal = "lince"

elegir animal {
    caso "gato"  { escribir("miau") }
    caso "lince" { escribir("es un felino ibérico") }
    otro         { escribir("no sé qué hace") }
}

funcion area(val numero base, val numero altura): numero {
    devolver base * altura / 2
}

escribir(area(10, 4))

funcion saludo(val texto nombre, val texto trato = "Hola"): texto {
    devolver trato + ", " + nombre
}

escribir(saludo("Ana"))
escribir(saludo("Ana", "Buenas"))

sea doble = funcion(val numero x): numero { devolver x * 2 }
escribir(doble(21))

sea nums = [1, 2, 3, 4]
escribir(mapear(nums, doble))
escribir(filtrar(nums, funcion(val numero x): logico { devolver x % 2 == 0 }))
escribir(reducir(nums, 0, funcion(val numero a, val numero x): numero { devolver a + x }))

sea golpes = [
    funcion(val numero f): texto { devolver "puñetazo de " + f },
    funcion(val numero f): texto { devolver "patada de " + f }
]
escribir(golpes[1](8))

sea acciones = {"saltar": funcion(): texto { devolver "¡hop!" }}
escribir(acciones["saltar"]())

funcion sumador(val numero a): funcion {
    devolver funcion(val numero b): numero { devolver a + b }
}
escribir(sumador(2)(3))

funcion contador_desde(val numero inicio): funcion {
    sea n = inicio
    devolver funcion(): numero {
        n = n + 1
        devolver n
    }
}

sea siguiente = contador_desde(10)
escribir(siguiente())
escribir(siguiente())
escribir(siguiente())

sea notas = [9, 7, 10]
notas.agregar(6)
escribir(notas)
escribir(notas.longitud())
escribir(notas.posicion(10))
escribir(notas.contiene(7))

sea original = [3, 1, 2]
escribir(original.ordenar())
escribir(original.invertir())
escribir(original + [4, 5])
escribir(original)

sea nums = [3, 1, 4, 1, 5]

escribir(nums.ordenar())
escribir(nums.ordenar(funcion(val numero a, val numero b): numero {
    devolver b - a
}))

sea persona = {"nombre": "Ana", "edad": 22}
persona["ciudad"] = "Córdoba"

escribir(persona["nombre"])
escribir(persona.longitud())

para cada texto clave en persona {
    escribir(clave + " = " + persona[clave])
}

importar "texto"

sea frase = "año de la cigüeña"
escribir(frase.longitud())
escribir(frase.mayusculas())
escribir(texto.dividir("a,b,c", ","))
escribir(texto.repetir("ab", 3))

sea nombre = "Ana"
sea vidas = 3
escribir("{nombre} tiene {vidas} vidas")
escribir("y {vidas * 100} puntos, {nombre.longitud()} letras")
escribir("lista: {[1, 2, 3]}")
escribir("\{\"vidas\": {vidas}}")

clase Rectangulo {
    funcion crear(val numero ancho, val numero alto): nulo {
        mi.ancho = ancho
        mi.alto  = alto
    }
    funcion area(): numero {
        devolver mi.ancho * mi.alto
    }
}

sea r = Rectangulo(4, 3)
escribir(r.area())

clase Figura {
    funcion crear(val texto nombre): nulo { mi.nombre = nombre }
    funcion describir(): texto { devolver "soy un " + mi.nombre }
}

clase Cuadrado extiende Figura {
    funcion crear(val numero lado): nulo {
        padre("cuadrado")
        mi.lado = lado
    }
    funcion area(): numero { devolver mi.lado * mi.lado }
}

sea c = Cuadrado(5)
escribir(c.describir())
escribir(c.area())

interfaz Forma {
    funcion area(): numero
    funcion describir(): texto
}

clase Rectangulo implementa Forma {
    funcion crear(val numero ancho, val numero alto): nulo {
        mi.ancho = ancho
        mi.alto  = alto
    }
    funcion area(): numero {
        devolver mi.ancho * mi.alto
    }
    funcion describir(): texto {
        devolver "Rectángulo " + mi.ancho + "x" + mi.alto
    }
}

clase Cuadrado implementa Forma {
    funcion crear(val numero lado): nulo {
        mi.lado = lado
    }
    funcion area(): numero {
        devolver mi.lado * mi.lado
    }
    funcion describir(): texto {
        devolver "Cuadrado de lado " + mi.lado
    }
}

sea lista formas = [Rectangulo(2, 3), Cuadrado(5)]
para cada elemento f en formas {
    escribir(f.describir() + " → " + f.area())
}

enumeracion Estado { Quieto Andando Saltando }

enumeracion Direccion {
    Arriba = [0, -1]
    Abajo = [0, 1]
    Izquierda = [-1, 0]
    Derecha = [1, 0]
}

funcion animacion(val Estado e): texto {
    elegir e {
        caso Estado.Quieto   { devolver "respirar" }
        caso Estado.Andando  { devolver "andar" }
        caso Estado.Saltando { devolver "saltar" }
    }
    devolver ""
}

sea estado = Estado.Andando
escribir(estado)
escribir(animacion(estado))
escribir(estado == Estado.Andando)

para cada Direccion d en Direccion {
    escribir(d.nombre + " mueve " + d.valor)
}
escribir(Direccion.Izquierda.indice)

clase Cuenta {
    privado sea saldo = 0

    funcion ingresar(val numero cantidad): nulo {
        mi.saldo = mi.saldo + cantidad
    }
    funcion consultar(): numero {
        devolver mi.saldo
    }
}

sea c = Cuenta()
c.ingresar(50)
escribir(c.consultar())

intentar {
    escribir(c.saldo)
} capturar (ErrorAcceso e) {
    escribir("No se puede: " + e.mensaje)
}

clase Pedido {
    estatico sea creados = 0
    estatico fijo IVA = 21

    funcion crear(val numero base): nulo {
        mi.base = base
        Pedido.creados = Pedido.creados + 1
    }
    estatico funcion con_iva(val numero base): numero {
        devolver base + base * Pedido.IVA / 100
    }
}

Pedido(10)
Pedido(20)
escribir(Pedido.creados)
escribir(Pedido.con_iva(100))

abstracta clase Figura {
    abstracto funcion area(): numero

    funcion describir(): texto {
        devolver "área " + mi.area()
    }
}

clase Cuadrado extiende Figura {
    funcion crear(val numero lado): nulo {
        mi.lado = lado
    }
    sobrescribe funcion area(): numero {
        devolver mi.lado * mi.lado
    }
}

escribir(Cuadrado(3).describir())

intentar {
    Figura()
} capturar (ErrorTipo e) {
    escribir(e.mensaje)
}

clase Vector {
    privado sea _x = 0
    obtener x(): numero { devolver mi._x }
    fijar x(val numero v): nulo {
        si v < 0 { lanzar Error("x no puede ser negativa") }
        mi._x = v
    }
    funcion sumar(val Vector b): Vector {
        sea r = Vector()
        r.x = mi.x + b.x
        devolver r
    }
    funcion menor(val Vector b): logico { devolver mi.x < b.x }
    funcion igual(val Vector b): logico { devolver mi.x == b.x }
    funcion a_texto(): texto { devolver "Vector(" + mi.x + ")" }
}

sea a = Vector()
a.x = 2
sea b = Vector()
b.x = 5
escribir(a + b)
escribir(a < b)
escribir(a == b)

intentar {
    a.x = -1
} capturar (Error e) {
    escribir(e.mensaje)
}

interfaz Saludable {
    funcion nombre(): texto
    funcion saludar(): texto {
        devolver "Hola, soy " + mi.nombre()
    }
}

clase Persona implementa Saludable {
    funcion nombre(): texto { devolver "Ana" }
}
clase Robot { }

sea p = Persona()
escribir(p.saludar())
escribir(p es Saludable)
escribir(Robot() es Saludable)
escribir(p es Persona)
escribir(5 es numero)

generador pares(val numero hasta): numero {
    para (i = 0; i <= hasta; i++) {
        si i % 2 == 0 { producir i }
    }
}

para cada numero p en pares(8) {
    escribir(p)
}

generador naturales(): numero {
    sea n = 1
    mientras verdadero {
        producir n
        n++
    }
}

para cada numero n en naturales() {
    si n * n > 50 {
        escribir("el primero con el cuadrado mayor que 50 es " + n)
        romper
    }
}

generador turnos(): texto {
    mientras verdadero {
        producir "Ana"
        producir "Luis"
        producir "Marta"
    }
}

sea quien = turnos()
para cada texto t en quien {
    escribir("ronda 1: " + t)
    si t == "Luis" { romper }
}
para cada texto t en quien {
    escribir("ronda 2: " + t)
    si t == "Ana" { romper }
}
para cada numero n en rango(1000000000) {
    si n == 3 { romper }
    escribir(n)
}

tarea parpadear(val texto quien, val numero veces) {
    para (i = 0; i < veces; i++) {
        escribir(quien + ": brilla")
        esperar()
    }
    escribir(quien + ": desaparece")
}

tarea jefe(): texto {
    escribir("jefe: carga el golpe")
    esperar(0.2)
    escribir("jefe: ¡golpe!")
    devolver "fin del ataque"
}

parpadear("moneda", 2)
parpadear("estrella", 3)
escribir(esperar(jefe()))

sea t = parpadear("vela", 100)
esperar()
t.parar()                  # se puede parar a medias
escribir(t.terminada())

intentar {
    sea lista nums = [1, 2, 3]
    escribir(nums[99])
} capturar (ErrorRango e) {
    escribir("fuera de rango: " + e.mensaje)
} capturar (error e) {
    escribir("otro error")
} finalmente {
    escribir("esto se ejecuta siempre")
}

funcion raiz_entera(val numero n): numero {
    si n < 0 {
        lanzar ErrorArgumento("no hay raíz real de un número negativo")
    }
    devolver n
}

intentar {
    escribir(raiz_entera(-1))
} capturar (ErrorArgumento e) {
    escribir("[" + e.tipo + "] " + e.mensaje)
}

intentar {
    escribir(noExiste())
} capturar (error e) {
    escribir("[" + e.tipo + "] " + e.mensaje)
}

intentar {
    sea cinco = 5
    escribir(cinco(1))
} capturar (ErrorTipo e) {
    escribir("[" + e.tipo + "] " + e.mensaje)
}

sea lista notas = [9, 7]

intentar {
    notas.agregar()
} capturar (ErrorArgumento e) {
    escribir("[" + e.tipo + "] " + e.mensaje)
}

intentar {
    notas[5] = 1
} capturar (ErrorRango e) {
    escribir("[" + e.tipo + "] " + e.mensaje)
}

clase Caja {
    funcion crear(val numero v): nulo { mi.v = v }
}

intentar {
    sea c = Caja(1)
    escribir(c.contenido)
} capturar (error e) {
    escribir("[" + e.tipo + "] " + e.mensaje)
}

importar "matematica"
importar "json"

escribir(matematica.raiz(144))
escribir(json.texto({"vivo": verdadero}))

importar "./lib_geometria"

escribir(area_circulo(1.0))

importar "./lib_metros" como metros
importar "./lib_pies"   como pies

escribir(metros.convertir(100))
escribir(pies.convertir(100))
escribir(metros.UNIDAD)

importar "./lib_figuras" como figuras

sea c = figuras.Cuadrado(3)
escribir(c.area())

importar "matematica"

escribir("{matematica.piso(3.9)} {matematica.techo(3.1)} {matematica.redondear(2.5)}")
escribir("{matematica.raiz(144)} {matematica.potencia(2, 10)} {matematica.abs(-7)}")
escribir("{matematica.maximo(3, 9)} {matematica.minimo(3, 9)}")
escribir(matematica.redondear(matematica.seno(matematica.PI / 2)))
escribir("{matematica.factorial(5)} {matematica.combinaciones(5, 2)}")
escribir("{matematica.grados(matematica.PI)} {matematica.distancia(0, 0, 3, 4)} {matematica.limitar(15, 0, 10)}")
sea dado = matematica.aleatorio(1, 6)
escribir(dado >= 1 y dado <= 6)

importar "texto"

sea partes = texto.dividir("rojo,verde,azul", ",")
escribir(partes)
escribir(texto.unir(partes, " y "))
escribir(texto.invertir("lince"))
escribir("{texto.posicion("perspicaz", "pica")} {texto.posicion("lince", "x")}")

importar "archivos"
importar "sistema"

sea ruta = "/tmp/lince_manual_ejemplo.txt"
archivos.escribir(ruta, "hola")
archivos.agregar(ruta, " mundo")
escribir(archivos.leer(ruta))
escribir(archivos.existe(ruta))
archivos.eliminar(ruta)
escribir(archivos.existe(ruta))

escribir(sistema.ejecutar("echo desde el sistema"))

importar "tiempo"

sea inicio = tiempo.ahora()
tiempo.esperar(0.02)
escribir(tiempo.ahora() - inicio >= 0)

importar "json"

sea datos = json.parsear("\{\"nombre\": \"Ñandú\", \"puntos\": [10, 25.5], \"activo\": true}")
escribir("{datos["nombre"]} {datos["puntos"][1]} {datos["activo"]}")
escribir(json.texto({"vidas": 3, "llaves": ["roja"]}))
escribir(json.texto({"vidas": 3, "llaves": ["roja"]}, verdadero))
intentar {
    json.parsear("\{\"roto\": ")
} capturar (error e) {
    escribir(e.mensaje)
}

importar "bytes"
importar "bits"

sea b = bytes.crear(6)
b.escribir_u16(0, 640)
b.escribir_u32(2, 4096)
escribir(b)
escribir("{b.leer_u16(0)} {b.leer_u32(2)} {b.longitud()}")

fijo SALTA = 0b0001
fijo DISPARA = 0b0010
sea estado = bits.alguno(SALTA, DISPARA)
escribir("{bits.binario(estado, 4)} {bits.ambos(estado, DISPARA) != 0}")
escribir("{bits.hex(255)} {bits.izquierda(1, 4)} {bits.de_hex("ff")}")

importar "pruebas"

funcion doble(val numero n): numero {
    devolver n * 2
}

pruebas.suite("doble")
pruebas.afirmar("doble de 4 es 8", doble(4) == 8)
pruebas.igual("una lista de dobles", [doble(1), doble(2)], [2, 4])
pruebas.lanza("dividir por cero da error", funcion(): nulo { sea x = 1 / 0 })
pruebas.resumen()

importar "tiempo"

sea t = tiempo.crear_utc(2024, 2, 29, 13, 5, 9)
escribir(tiempo.formatear_utc(t, "%d/%m/%Y %H:%M"))
escribir(tiempo.formatear_utc(t + 86400, "%Y-%m-%d"))

sea p = tiempo.partes_utc(t)
escribir(p["anio"])
escribir(p["dia_anio"])

escribir(tiempo.analizar_utc("2024-02-29 13:05:09", "%Y-%m-%d %H:%M:%S") == t)
escribir(tiempo.analizar_utc("no es una fecha", "%Y-%m-%d"))

importar "juego"

# ¿se tocan el jugador y el enemigo? (x, y, ancho, alto de cada uno)
escribir(juego.colision(10, 10, 32, 32, 30, 30, 32, 32))
escribir(juego.colision(10, 10, 32, 32, 100, 100, 32, 32))

# ancho en píxeles de un texto, para centrarlo en la pantalla
sea ancho_pantalla = 800
escribir((ancho_pantalla - juego.ancho_texto("GAME OVER", 4)) / 2)

lince programa.lince                    # ejecutarlo
lince comprobar programa.lince          # solo la sintaxis
lince compilar programa.lince -o prog   # un ejecutable con todo dentro
lince nuevo mi_juego                    # una carpeta con un juego para empezar
lince version

lince depurar programa.lince
→ programa.lince:1   importar "juego"
(lince-dbg) b programa.lince:12
(lince-dbg) c
(lince-dbg) p jugador["vida"]
(lince-dbg) v
(lince-dbg) n

$ lince
🐆 Lince v0.9.0 — Escribe :ayuda para ver los comandos
>> sea vidas = 3
>> vidas * 10
=> 30

lince instalar https://github.com/usuario/paquete
lince listar
lince desinstalar paquete
code --install-extension lince-language-X.Y.Z.vsix   # viene con cada versión