Vale, os cuento un poquito qué es RAST y no es el videojuego, ¿vale?
RAST es un lenguaje de programación compilado, compilado, y se dice que es un lenguaje de programación de sistema.
¿Qué significa que es de sistema? Pues que es un lenguaje de programación que como tal no suele estar pensado tanto para hacer aplicaciones de interfaz gráfica.
Como por ejemplo C++, le pasa exactamente lo mismo, sería como el mismo lenguaje de, o sea, el mismo tipo de lenguaje de programación, un lenguaje de programación de sistemas, ¿vale?
O sea, está pensado más para hacer drivers, para hacer sistemas operativos, para hacer todo tipo de cosas.
Eso no quiere decir que luego no se pueda utilizar para otras cosas, por ejemplo C++ o C++, como ya sabéis, C++ pues al final se ha utilizado hasta para hacer videojuegos en esta vida.
Así que lo mismo pasa con RAST, ¿vale? RAST la idea es eso, que sea de propósito general, pero es un lenguaje de programación de sistemas, no he pensado tanto para interfaces, aplicaciones de interfaz,
pero el creador de RAST es Mozilla.
¿Y por qué creó Mozilla el lenguaje de programación de RAST?
Pues lo creó justamente para Firefox.
Así que a día de hoy, si estáis utilizando Firefox, estáis utilizando ya RAST.
Es seguramente la aplicación de escritorio más famosa a día de hoy que está utilizando ya en producción RAST.
Y no es para menos. O sea, su rendimiento ha mejorado un montón desde que está utilizando RAST.
Y es que si una cosa tiene RAST en cuanto a cómo se ha diseñado y para qué se ha diseñado, es para eso.
Para que sea un lenguaje de programación que es seguro, que tiene que ser práctico y pensado en la concurrencia, ¿vale?
Seguro, práctico, pensado en la concurrencia, que sea confiable, que sea también pues algo fácil más o menos de escribir,
aunque una de las cosas que dicen justamente...
Menos mal que son máximo seis horas.
Bueno, si todavía queda. Mira, tenemos ahí dos. O sea, que nos queda la vida, hombre, Waken.
Pero gracias por los bits. Muchas gracias.
Aunque Firefox es más lento que Chrome, dice Lavaldi.
Bueno, bueno. Lo que sí que... Yo creo que Firefox es bastante rápido.
Al menos yo lo noto bastante rápido.
Dino también está en RAST. Hay un montón. Por ejemplo, también lo utiliza Dropbox, NPM, Microsoft, GitHub.
¿Qué más? ¿Qué más? Y es que Amazon también lo está utilizando.
Lo utilizan un montón de empresas. De hecho, podríamos verlo en la página web oficial, ¿vale?
RAST, como os decía, es de mochila. Pero si tiene una cosa mochila que es bastante interesante cuando crea y genera desarrollos,
es que los hace totalmente abiertos, ¿no? O sea, no solo por el tema de que sea open source, que eso lo podría ser cualquiera,
sino que digamos que el desarrollo lo delega, ¿vale? A la comunidad directamente.
O sea, no se lo queda como compañía. Como, yo qué sé, puede pasar con WebKit o Blink,
que son los motores de los navegadores de Apple y de Google, respectivamente.
Claro, son de código abierto, pero digamos que el desarrollo está liderado por ellos mismos.
O como pasa con RIA, que es de código abierto, pero es Facebook, ¿no?
Quien decide qué es lo que entra y tal.
Bueno, en el caso de RAST, está como totalmente liderado por la comunidad.
Esto es totalmente diferente a otros lenguajes de programación.
TypeScript, sin ir más lejos, aunque más o menos está liderado por la comunidad.
En realidad, quien está detrás es Microsoft.
En este caso, al final, lo que han dicho es mochila, decir, bueno,
pues vamos a hacer que esto sea un proyecto totalmente comunitario.
Así que eso es otra cosa que es bastante interesante.
Y, por supuesto, que RAST es multiparadigma.
De hecho, vamos a ir a la página web para empezar a conocer un poquito más de RAST.
Ah, ya veo que estáis estrenando los nuevos emojis.
Que hay nuevos, un montón de emojis nuevos.
Un montón de emojis nuevos.
Bueno, pues aquí tenemos RAST.
Un lenguaje para empoderar a cualquier persona a construir software eficiente y confiable.
Eso es lo que es RAST.
Eso es RAST.
¿Y por qué RAST?
Uno, performance, porque es muy rápido, muy rápido y muy eficiente en cuanto a manejo de memoria.
Confiable, porque tiene, además de que el sistema de tipos, tiene tipos estáticos, por supuesto.
Es compilado el lenguaje.
Te dice warnings, errores cuando lo compilas.
Incluso te dice, oye, esto que estás haciendo a lo mejor no es justamente algo que deberías estar haciendo por X motivo.
¿Vale?
Por temas de memoria o lo que sea.
Y productividad.
Tiene muy buena la documentación.
El compilador da errores muy útiles, a diferencia de lo que ha pasado históricamente con otros lenguajes compilados.
Y además, pues tienes ya tu administrador de paquetes.
Igual que tenemos NPM en Node o tenemos PIP en Python, pues también tenemos en RAST cargo.
Que como veremos, ya lo iremos conociendo, pero cargo es el administrador de paquetes de RAST.
Bueno, es que tiene un montón de cosas.
¿Para qué se puede hacer con RAST?
Esto es una de las cosas que mucha gente me pregunta.
Oye, ¿qué se puede hacer con RAST?
¿Para qué sirve RAST?
¿A qué me dedico?
Ya te he dicho que se está utilizando en Firefox.
Si estáis utilizando Firefox, estáis utilizando RAST.
Pero también se puede hacer un montón de cosas interesantes.
Crear aplicaciones de la línea de comandos, o sea, de la terminal.
De hecho, si lo habéis visto hace poco, Next.js, vamos a ver, Next.js.
Teníamos esta noticia, ¿verdad?
De que Next.js, que es el framework de React por excelencia, pues dice que está haciendo, bueno, que ha mejorado bastante la velocidad de sus compilaciones.
¿Y cómo lo ha conseguido?
Pues lo ha conseguido gracias a utilizar SWC.
¿Y qué es SWC?
Pues un compilador de JavaScript que está escrito con RAST.
O sea, la alternativa de Babel, ¿vale?
SWC es la alternativa de Babel, pero escrita con RAST.
Y esto es muy interesante.
Fíjate, SWC es 20, 20 veces más rápido que Babel.
Pero esto en un solo thread.
En multithread es hasta 70 veces más rápido.
O sea, más rápido revienta.
O sea, que tiene muy buena pinta.
Por cierto, que acaban de actualizar la documentación de SWC, por lo que veo, para unificar un poco el diseño con los productos de Eversell.
Lo cual me parece muy bien porque les ha quedado realmente bonito.
Esta es una de las grandes, yo creo, uno de los, no sé, creo que aquí es donde el ecosistema de RAST se va a mover mucho, ¿no?
En este tipo de herramientas para el desarrollo web.
Creo que RAST vamos a ir viendo poco a poco cómo va a ir como matando, digamos, algunas de las herramientas que hasta el día de hoy estaban hechas con JavaScript.
Por ejemplo, en lugar de utilizar Webpack, pues empezaremos a utilizar más SWC Pack.
Porque de hecho existe, lo tenemos aquí.
Ah, pues aquí ahora ya no está.
A ver, está el CLI, el Core.
Este es que tiene su propio SWC Pack, pero bueno, me imagino que ahora lo han quitado porque lo tienen todavía un poco, está todavía en beta.
Y por eso a lo mejor se lo han petado aquí.
Pero que sepa que existe, ¿eh?
¿Es ese pack o ese pack o algo así?
Mira, aquí estaba la Bundling Configuration, ¿ves?
Aquí en Bundling es capaz de hacer bundelizado, o sea, que también se puede hacer un bundle con SWC.
Pero bueno, que Dino, pues también utiliza RAST.
En lugar de utilizar Node, que está todo por detrás, está con C++ y está con JavaScript, pues Dino utiliza RAST, por ejemplo.
O sea, que tiene un montón de utilidades.
También puedes compilar a WebAssembly.
Esto significa que lo que haces en RAST lo podrías llegar a utilizar en una página web utilizando WebAssembly.
O sea, imagínate esto, la pedazo de mejora de rendimiento de un montón de cosas que a día de hoy se intenta hacer con JavaScript y no puede ser.
Ahora bien, aviso para navegantes.
Esto no significa que RAST de repente va a usarse en lugar de JavaScript, ¿vale?
Eso no va a ser así.
JavaScript siempre va a tener mil millones de ventajas respecto a RAST para hacer interfaces de usuario y para tener acceso al DOM.
Es mucho más fácil, no hay que compilarlo, el bytecode que te sale es muy pequeñito.
O sea, tiene problemas en otros aspectos.
Pero hacer interfaz de usuario no creo a día de hoy, empezas a ver el largo plazo, de que va a valer la pena compilar en RAST para hacer la interfaz del usuario.
A lo mejor para cosas en 3D sí, pero ese es otro tema, ¿vale?
Entonces, networking también.
Bueno, networking tampoco es muy interesante, pero es para hacer servicios de red.
Y, por supuesto, para Internet of Things, cosas en medidas, cosas que sean de bajo nivel.
¡Hostia, 300 bits!
¡Madre mía, madre mía!
¡Magrebs, muchas gracias!
Bueno, aquí tenemos en producción que lo utiliza NPM, Yelp, a ver quién más lo utiliza, pero ya Dropbox, este sí que lo he comentado.
Ya os digo que GitHub, Microsoft, ¿qué más?
Azure no, Amazon también lo está utilizando.
Hay un montón de casos de éxito de RAST.
Así que os recomiendo mucho este artículo de Lou Robinson, que es un developer advocate de Bercel, y te explica, mira, aquí tenemos todos los ejemplos donde Facebook, por ejemplo, utiliza, Apple lo usa, Amazon también lo usa.
Y por qué además, esto es muy interesante, por qué RAST está sonando tanto, por qué lo deberíamos aprender, además de todo lo que te he dicho.
Bueno, pues que resulta que durante seis años seguidos, en las encuestas del Stack Overflow, desde el año 2016, o sea, en todas las encuestas que se ha ido haciendo año tras año, en todas y cada una de las encuestas, RAST siempre ha salido como el lenguaje más amado.
Y además, a distancia del resto.
Esto lo que quiere decir es que aunque no hay mucha gente, no hay mucha gente a día de hoy que esté utilizando RAST, porque si miramos el número de gente que utiliza RAST respecto a JavaScript, por JavaScript está muy por encima, pero la gente que utiliza RAST lo ama, ¿vale?
Así que, bueno, eso es lo interesante sobre todo de este lenguaje, que cada vez más hay más comunidad, más gente lo está adorando, y además estamos viendo que más y más herramientas se están migrando a ello.
Bueno, aquí tenemos Facebook, ¿cómo utiliza RAST? Mira, pues de 2016, como le iba comentando, y tal. Hay un montón de Apple también está utilizando RAST, ¿vale? AWS también RAST.
Mira, cómo ama RAST. Yo creo que es un buen momento, ahora si alguien me pregunta, yo creo que ahora es un buen momento para aprender RAST, y por eso yo no tengo ni puñetera idea de RAST, pero vamos a aprender sobre ello.
Así que, vamos a hacer el curso desde cero de Microsoft. Que no sabes RAST, no te preocupes, porque yo tampoco sé RAST, así que al final vamos a aprender todo juntos, ¿eh?
Vite está hecho con Sbuild, ¿vale? Vite, que es la alternativa también a Webpack, Vite está utilizando por detrás Sbuild, y Sbuild está hecho con Golang, que Golang es súper rápido también,
como podéis ver Sbuild le pasa la mano por la cara también al resto, pero no está utilizando RAST, ¿vale? Está utilizando, en este caso, está utilizando Golang, que bueno, sería otra alternativa.
Pero yo creo que cada vez más se están viendo más y más proyectos con RAST, ¿eh? Así que, ¿SWC es compatible con los plugins de Webpack o Rollup?
¿SWC no es compatible con los plugins de Webpack o Rollup? Y de hecho, SWC per se es más parecido a Babel que a Webpack, pero tiene como una cosita que es SWPack o algo así,
pero sigue sin ser compatible con esos plugins. O sea que no. Habrá que empezar a crearlos y generarlos.
Bueno, pues vamos a empezar. Primeros pasos con RAST. Os han dejado en el chat ahí todos los enlaces. Así que, 5 horas y media que tenemos por delante.
Así que, ponte cómodo o cómoda y vamos a empezar. Venga. Primeros pasos con RAST. 11 módulos.
¿Estás interesado en aprender un nuevo lenguaje de programación que está creciendo en uso y popularidad? Ojo, cuidado. Y de hecho, se paga muy bien. Así que...
Si dice, ¿cuánta experiencia tienes con RAST? 0, Calium. Tengo 0, patatero. Así que le vamos a dar.
Venga. Vamos a empezar por aquí. Siente la base del conocimiento que necesitas para compilar programas rápidos y eficaces en RAST.
Nos va a explicar cómo instalar las herramientas, aprender los conceptos básicos, administrar la memoria, que esto va a ser una cosa bastante interesante.
Usar tipos y rasgos genéricos, configurar módulos para paquetes, escribir y ejecutar pruebas automatizadas.
O sea, testing y todo. Testing y todo. Y al final, vamos a conseguir crear una herramienta de línea de comandos.
Si veo que nos gusta RAST a todos y tal, pues seguiremos haciendo más directos sobre RAST.
Vamos a continuar. Vamos a empezar. ¿Qué es RAST? Venga. RAST es un lenguaje de programación de sistemas de código abierto.
Fíjate, de sistemas. Esto es la diferencia de aplicaciones. No está pensado para aplicaciones de interfaz.
Pero ya veremos que esto puede cambiar. ¿Qué puede usar para desarrollo de software seguro y eficaz?
Con RAST puede administrar la memoria y controlar otros detalles de bajo nivel. Esto es muy importante.
RAST es un lenguaje de bajo nivel. Esto quiere decir que está más cerca de la plataforma.
No tiene como tanto azucarillo sintáctico o no es tan bonito quizás de ver, sino que te tienes que preocupar de ciertas cosas
que te van a ayudar a gestionar mejor la memoria.
Pero controlar otros detalles de bajo nivel. Esto es lo que también mejora el rendimiento.
Pero también puedes aprovechar los conceptos de alto nivel, como iteración e interfaces.
Esto es una cosa que habla muy bien de RAST, justamente.
Estas características distinguen a RAST de los lenguajes de bajo nivel como C y C++.
Y es verdad. Esto siempre ha sido uno de los problemas que ha tenido históricamente tanto C como C++.
Y es el hecho de que como eran tan, tan, tan de bajo nivel, pues el cómo tenías que gestionar tú la memoria y todo esto,
pues era ciertamente complicado.
Dicen que RAST también tiene su curva de aprendizaje, pero bueno, vamos a ver.
¿Qué más ofrece ventajas RAST?
Pues que lo hacen ideal para una amplia de aplicaciones porque tienes seguridad de tipos,
el compilador garantiza que no se va a aplicar ninguna operación a una variable de un tipo incorrecto,
seguridad de memoria, los punteros de RAST conocidos como referencias,
siempre hacen referencia a la memoria válida.
Bueno, tiene algunos conceptos que te pueden recordar incluso a JavaScript si sabes cómo se trabaja con objetos y con arrays.
Sin carrera de datos. Bueno, carrera de datos, yo supongo que aquí lo que quiere decir una race condition, me imagino.
El comprobador de préstamos de RAST garantiza la seguridad para subprocesos asegurándose de que varias partes de un programa
no pueden mutar el mismo valor al mismo tiempo.
Importante porque RAST apuesta por la concurrencia, ¿vale?
Abstracciones de costo cero.
RAST permite el uso de conceptos generales como iteración, interfaces y programación funcional con un costo de rendimiento mínimo o nulo.
Las abstracciones funcionan tan bien como si hubiera escrito el código subyacente a mano.
Esto es normalmente uno de los grandes problemas que ha tenido otros lenguajes de bajo nivel,
que para hacer, pues, una iteración, pues, tenías tú que moverte ahí y hacer, pues, andar a las referencias a mano, a memoria y tal.
O sea, que aquí parece que es más bien de alto nivel en ese aspecto.
¿Vale?
Entorno de ejecución mínimo.
RAST tiene un entorno de ejecución mínimo y opcional con el fin de administrar la memoria de forma eficaz.
Así que, en este caso, sí que se parece más al lenguaje como C y C++.
Destino sin sistema operativo.
RAST puede tener como destino la programación insertada sin sistema operativo,
lo que le hace adecuado para escribir un kernel de sistema operativo controlador de dispositivo.
Ojo con esto, porque justamente, yo creo que vamos a ver poco a poco,
no solo como algunas aplicaciones como Visual Studio Code, terminales, navegadores, que ya lo hemos visto,
no solo vamos a ver que cada vez más este tipo de aplicaciones utilizan RAST,
sino que no me extrañaría que veamos que algunos sistemas operativos
empiezan a incorporar módulos de RAST, como por ejemplo Linux.
No me extrañaría que Linux empieza a escribir partes del kernel con RAST,
si no lo está haciendo ya, lo cual, sinceramente, desconozco.
Pero yo creo que es una cosa que seguramente va a tener bastante en cuenta.
Ah, mira, Google ya está reescribiendo el kernel de Linux a todo RAST.
Pues me lo creo y tiene bastante sentido.
Según la encuesta desarrollada de Stack Overflow de 2021,
RAST ha sido el lenguaje más apreciado durante varios años seguidos.
Los desarrolladores disfrutarán de la programación con RAST, ¿vale?
Comprobación de conocimientos.
¿En qué se parece más RAST a C y C++?
RAST es un lenguaje con seguridad de tipos, seguridad de memoria y sin carrera de datos.
RAST tiene un entorno de ejecución mínimo y opcional.
RAST se puede usar para resolver un kernel de sistema operativo
o un controlador de dispositivo.
A ver, yo creo que en todos se parece, ¿no?
Con seguridad de tipos.
Bueno, seguridad de tipos.
Creo, si no recuerdo mal, que C++ es dinámico.
Los tipos son dinámicos.
Así que entiendo que el primero no puede ser.
El segundo, a ver, en realidad en C y C++ hay,
pero entiendo que el más correcto sería el tercero, ¿no?
¿En qué se parece más RAST a C++?
C++, yo creo que en este.
Tiene un entorno de ejecución mínimo y opcional.
Yo creo que es este.
Vale, correcto.
Muy bien, 400 experiencias.
Perfecto.
Claro.
A ver, también se puede hacer kernel y tal,
pero como ha dicho lo que más se parece, entiendo que es la tercera.
Características únicas de RAST.
Para averiguar si un lenguaje de programación es adecuado para un proyecto,
tienes que conocer las características.
Muy buena frase, me parece muy bien.
Y las limitaciones.
Esto no quiere decir ahora que RAST sea lo mejor para todo, ¿vale?
Así que tengámoslo en cuenta.
Vamos a comparar los lenguajes posibles y elegir el que mejor funcione.
En esta unidad revisaremos algunas de las características y limitaciones de RAST.
Limitaciones.
Sistema de módulos de RAST.
Módulos, crates y rutas.
Bibliotecas estándar de RAST y crates de terceros.
Crates, cuando leáis crates, son como los paquetes de Node, básicamente.
La herramienta cargo de RAST y el administrador de dependencias.
Esto sería nuestro NPM.
Y cuándo se debe usar RAST.
Vamos con el primero.
Administración de código con el sistema de módulos de RAST.
RAST ofrece una colección de características que le ayudarán a administrar y organizar el código.
Estas características se conocen como sistema de módulos de RAST.
El sistema se compone de crates, módulos y rutas.
La verdad es que aquí me deja un poco loco.
Crates, módulos y rutas.
Así como herramientas para trabajar con estos elementos.
Vamos a ver qué significa cada una de las tres cosas.
Crates.
Un crate de RAST es una unidad de compilación.
Es el fragmento de código más pequeño que puede ejecutar el compilador de RAST.
El código de un crate se compila en conjunto para crear un archivo ejecutable binario a una biblioteca.
Porque recordemos que RAST es un lenguaje compilado.
En RAST solo los crates se compilan como unidades reutilizables.
Un crate contiene una jerarquía de módulos de RAST con un módulo implícito de nivel superior sin nombre.
O sea, diríamos que ese es como el punto de entrada.
Módulos.
Los módulos de RAST ayudan a organizar el programa ya que permite administrar el ámbito de los elementos de código individuales dentro de un crate.
Bueno, módulos, esto se parece un poco a los módulos que tendríamos en JavaScript.
Las definiciones de códigos recursivas pueden abarcar otros módulos.
Perfecto.
Y RAST.
Puedo usar rutas para dar nombre a los elementos del código.
Por ejemplo, una ruta puede ser una definición de datos.
Un vector, una función de código, incluso un módulo.
La característica del módulo también le ayuda a contrarre la privacidad de las rutas.
O sea, esto sería un poco, yo entiendo, como para evitar o para hacer qué parte tiene que ser pública,
qué parte tiene que ser privada, o si no quieres que los detalles de implementación se vean y todo esto.
Venga.
Agüita.
No, vamos a empezar a leer ahora, pero dentro de poco estaremos ya escribiendo.
Uso de crates y bibliotecas de RAS.
Tiene una biblioteca estándar.
Una biblioteca estándar, para que no lo sepáis, digamos que tiene las operaciones más importantes del lenguaje de programación.
Node, como tal, no tiene una biblioteca estándar, pero todo lo que tendríamos en la documentación sería como su biblioteca estándar.
Esta documentación de referencia, todas las cositas que tenemos por aquí, que puedes importar y tal, eso diríamos que es un poquito la biblioteca estándar.
Solo que aquí lo tienen como separado.
La biblioteca tiene definiciones para tipos de datos principales, string, claro, es que en JavaScript, digamos que esto está como una forma global ya disponible directamente.
Hay decenas de miles de bibliotecas y crates de terceros disponibles, aparte de la estándar, que es la que viene por defecto.
Más adelante veremos cómo podemos acceder a estos crates, ¿vale?
STD, que es estándar, la biblioteca estándar de RAS.
En los ejercicios de RAS verás que aparecen los siguientes módulos.
Para manejar colecciones, para manejar con el entorno, me imagino para poder leer variables de entorno.
Para el formato de salida, file system, ¿vale?
FS, file system, el sistema de archivos, esto sería muy parecido al de Node.
IO, pues entrada y salida.
Y para el path, ¿vale?
El sistema de archivos.
Estos son crates que serían de terceros.
Pues esto para trabajar con las fechas, para regex.
Y esto serialización, ¿no?
Ser y de, serialización y deserialización de estructuras de datos.
Y struct op para analizar argumentos de línea de comandos.
Esto nos va a servir para cuando hagamos la aplicación de la línea de comandos.
De manera predeterminada, la biblioteca STD está disponible para todos los crates de RAS, ¿vale?
Es normal, o sea, está totalmente lo que decía.
Igual que Node, pues tiene disponible ya la biblioteca sin instalar nada.
Y entonces tenemos que utilizar la palabra clave use.
Algo parecido al import de JavaScript, pues sería con use.
Con la palabra clave use, el código del crate o biblioteca se incluye en el ámbito.
Esto sería muy parecido, muy parecido a la palabra import para los módulos de JavaScript.
¿Vale?
Aquí nos dice un poco cómo se pueden crear.
Se puede usar el compilador RAST para crear crates.
En la mayoría de proyectos, bueno, aquí tendríamos como unos cuantos comandos que podemos utilizar a la hora de utilizar cargo.
Cargo es como el NPM, pero de RAST, ¿no?
Y podemos crear un nuevo proyecto, lo podemos compilar, compilar y ejecutar, ejecutar los test, comprobar los tipos, compilar la documentación y publicarlo, ¿vale?
Venga, ¿cuándo se debe usar RAST?
Que esto es lo interesante.
El lenguaje RAST tiene numerosos puntos a favor que se deben tener en cuenta al elegir el mejor lenguaje.
RAST permite controlar el rendimiento y los consumos de recursos al mismo nivel que C y C++.
Al mismo tiempo que mantiene la memoria protegida, ya que elimina todas las clases de errores comunes de manera predeterminada.
Bueno, esto es porque cuando intentas compilar, pues seguramente pétala.
Te dirá, oye, esto no lo puedes hacer y tal.
RAST tiene características de abstracción completas, ¿vale?
De los aspectos invariables de sus programas de código.
Esto entiende características de abstracción muy completas.
Esto entiende que...
Mira, esta característica suele dar lugar a la impresión de que si se compila, funciona.
Bueno, esto entiendo que es eso, ¿no?
Que el tema es que te puedes fiar del compilador.
El RAST tiene herramientas integradas para compilar.
Gracias a estas herramientas puedes hacer, pues, tareas difíciles como hacer testing, crear dependencias, compilar.
Claro, esto lo tendríamos todo aquí.
Ya lo tendríamos que crear.
En JavaScript, cuando tienes que compilar, pues, tienes que instalar que si va a ver, que si tienes que instalar SWC.
Pues, aquí lo que tienes con cargo, digamos, es un poco de todo ya directamente, ¿no?
¿Cómo se ejecuta el código de RAST?
Vamos con la comprobación de conocimientos.
El código de RAST debe ser incluido en un archivo de código fuente de C++.
Sí, claro, claro que sí.
RAST interpreta los scripts a través de la compilación seguida de la ejecución directa.
Vale, yo creo que es este, ¿no?
No interpreta, tiene que compilar.
Y, hombre, el código de RAST, si tiene que ser incluido en el archivo de código fuente de C++, sería un poco jodido.
¿Cuál sería un ejemplo de algo que no se puede hacer con cargo?
Pues, hostia, publicar una biblioteca en crates.io, compilar un proyecto de RAST existente, actualizar la versión del compilador de RAST.
Esto es lo que no se puede hacer, ¿vale?
Yo creo, bueno, porque aquí no hemos visto en todas las tareas lo que se puede hacer, no se puede actualizar la versión del compilador de RAST instalada.
Esto es básicamente lo mismo que ocurre con MPM.
Tú utilizando MPM no puedes actualizar Node, ¿vale?
Tiene sentido, porque al final es para gestionar paquetes o el proyecto en sí.
Pues, creo que estas son.
Vamos a ver.
Muy bien, las dos son correctas.
Oye, me da mucha rabia que si le doy aquí a continuar, ya no veo.
Dice, correcto, el código de RAST se compila en un archivo ejecutable y luego se ejecuta.
No se puede actualizar la versión del compilador de RAST mediante cargo.
Tienes que utilizar RAST app, ¿vale?
Área de juegos de RAST.
Venga, que vamos con el playground ya.
Bueno, hay veces que solo quieres probar un poco de código, ¿no?
Para la sintaxis y todo esto.
Pues, tenemos este PlayRAST LANG, que es como un IDE para desarrollar un RAST en la red.
Pues, vamos a entrar y vamos a verlo.
Vamos a empezar a verlo.
En la captura de pantalla se muestra el entorno del área de juegos.
En el extremo derecho de la barra de herramientas, el menú config tiene opciones para establecer las preferencias del entorno.
¿Vale?
Código de formateo.
¿Qué es lo que nos permite?
Bueno, la herramienta da formato al código.
O sea, que también tiene como su propio Priter o tal, ¿no?
Entiendo, RAST FMT.
Para seguir los estilos oficiales de RAST.
Claro, aquí se acabaron las discusiones del Inter, de Format y de hostias.
Probar código.
La herramienta Clippy con pruebas.
¿Clippy?
Clippy es lo de Microsoft.
¿Clippy?
Este es Clippy.
¿Qué dices?
¿Que RAST tiene su propio Clippy?
La herramienta ejecuta pruebas de Lint.
Guardar código.
Más de vídeo que se trabaje, el sitio almacenar código.
Compartir código.
¿Vale?
Opciones de compilación, RAM, build y test.
Nada.
Límites de protección.
A ver, hay algunas limitaciones en el área de juego, como era de evitar, ¿no?
Al compilar, no hay disponible una conexión de red, la memoria, limita la memoria disponible,
tiempo de ejecución.
Vale.
Esto es normal, ¿vale?
Porque esto es un playground.
Esto es un playground.
Este es justamente el playground de RAST, ¿no?
Claro, pues tiene algunas limitaciones, obviamente, para no reventarlo.
¿Qué herramienta del área de juegos de RAST se puede usar para encontrar errores en
el código?
Hostia, errores en el código.
Entiendo.
Es que no sé si sería el Clippy o sería el RAST.
Bueno, sería Clippy, ¿no?
Entiendo que sería Clippy.
Que es el que linta.
Clippy.
Cuando no está disponible una conexión de red en el sitio de pruebas de RAST, cuando
se edita, cuando se ejecuta, cuando...
Entiendo que al compilar o ejecutar, ¿no?
Al compilar o ejecutar.
Porque, hombre, cuando se edita no tiene sentido, cuando se ejecuta un poco.
Al compilar o ejecutar.
¿Vale?
Muy bien, correcto.
Puede usar la colección Clippy de pruebas de Lins y compilar código, tal.
Perfecto.
Pues venga, vamos con el ejercicio.
Primer ejercicio de RAST.
Escritura de código en el área de juegos.
¿Vale?
Dice que vayamos a RAST, que es aquí.
Y escriba el código siguiente en el editor del área de juegos.
Bueno, este sería nuestro Hello World.
Que veo que ya está aquí escrito.
Pero, bueno, vamos a hacerlo nosotros a mano.
Va.
Dice FN.
Que entiendo que esto será para las funciones.
El nombre de la función.
Se ejecuta así.
No tiene ningún tipo de parámetro.
Y aquí dice que tenemos que utilizar el método println.
Y esta exclamación.
Hostia, esta exclamación es muy rara.
Espero que me la expliquen.
Println.
Tiene que terminar en semicolon.
Importante.
Y aquí, aquí me extraña.
Yo creo que esto está mal.
Porque aquí pone welcome to RAST.
Y aquí, fíjate que no le pone ni...
¿Sabes?
Lo pone así.
Welcome to RAST.
Yo creo que esto está mal.
Pero, bueno, está bien que nos pete.
¿Sabes?
Yo creo que tiene que ponerle comillas o algo.
¿Ves?
Mira, ya nos dice, oye, que lo estoy compilando y no se puede compilar porque esperaba una coma.
No.
Yo lo que creo que es que aquí esto tiene que ser así.
Como si fuese un string.
Le damos a run.
Y a ver ahora.
Tarda o suyo, ¿eh?
Pensaba que sería más rápido.
Supongo que...
A ver, esto está en una máquina virtual.
La compilación no está ocurriendo en esta máquina.
Está ocurriendo fuera.
Hostia.
Pues empieza bien, ¿no?
Porque aquí dice entry point.
O sea, esto tiene pinta de ser un error de fuera.
Ni siquiera es aquí.
Ni siquiera este error es aquí.
Me parece a mí que ha petado la máquina de fuera y ya.
¿No?
Bueno.
Si no, lo podemos probar cuando instalemos...
Ah, mira, sí.
Es que tenía clip y le tenía que decir el error.
Yo es que me he adelantado, ¿sabes?
Y dice, vale, añade las comillas.
Y luego, compilación y ejecución.
Ahora se compilará el código o se ejecutará el programa.
Bueno, ya vemos que ejecutar no se compila.
O sea, vamos a hacer solo un build a ver si funciona mejor.
Pero desde luego a mí.
O sea, primero es Hello World y ya.
Explotamos Rust.
Bueno, entiendo que el problema está más bien en el playground,
que no le está gustando esto.
Y luego, vale, nos dice que le podemos dar aquí a compartir.
Aunque ya vemos que no es muy útil que lo compartamos.
Aquí en share.
Y esto nos debería hacer una URL o algo para compartir el programa, ¿no?
Vínculo permanente, bla, bla, bla.
Vale.
Bueno, como no entiendo...
Mira, aquí tenemos share, permalink al playground,
direct link to the gift.
Esto es para compartir el código.
¿Vale?
Pero nada, que no funciona, ¿eh?
A mí me parece que no...
Stable channel, pero no funciona el playground.
Se lo han cargado.
Se lo han cargado.
Vale.
Total, lo vamos a hacer nosotros.
Vamos a intentarlo...
Lo he puesto bien, ¿no?
A ver si a culpa es mía que hay algo que no he puesto bien, pero...
No, pero yo creo que no, que lo he puesto bien, ¿no?
Ah, a ti tampoco te va.
Vale, pues ya está.
Ya dicen por el chat que no va.
Vale.
Lo que vamos a hacer da igual, porque lo vamos a hacer en local
y ahora lo ejecutaremos bien.
En resumen, bueno, todo lo que hemos aprendido.
El comando rastab para configurar el entorno de desarrollo.
El comando rastc para compilar.
¿Has descubierto la característica de cargo?
Bueno, pero todavía no he hecho nada.
Prueba las recetas.
Al final hemos hecho eso.
Vamos a continuar con el módulo siguiente, porque total...
Total.
Esto.
Esto es lo que interesa.
Configurar el entorno de desarrollo de rast.
Vamos a iniciarlo en nuestra máquina.
Esa inicia así un poco de aquella manera.
La verdad es que prefiero no utilizar un Playground.
Vamos a intentar hacerlo en nuestra máquina.
Introducción.
Venga.
Primero vamos a instalar Visual Studio Code.
Bueno, instalar Visual Studio Code ya lo deberíamos tener.
Si no lo tenéis, lo instaláis, ¿vale?
Pero yo entiendo que lo interesante debe ser algún tipo de...
Vale, esto es para instalar Visual Studio Code.
Espero que todos tengáis Visual Studio Code.
¿Cuáles son los dos comandos que compilan un programa de rast?
Hostia, esto me lo ha preguntado aquí de repente.
Porque aquí, en este artículo, no está hablando de nada de esto.
¿O sí?
Bueno, a ver, era rast, eso seguro.
Y, hostia, ahora no me acuerdo de este.
Este era cargo build.
Cargo build.
Es cargo build y rast.
Dos comandos que compran un programa.
Es cargo build.
Cargo es el npm este que teníamos.
Y el rast.
¿Vale?
Muy bien.
Siguiente.
Instalación de esa herramienta de combinación de Visual C++.
Rast requiere las herramientas de combinación de Microsoft C++ para Visual Studio 2013 posteriores.
Bueno, esto es si tenéis Visual Studio C++.
O sea, si vais a utilizar ese tipo de herramienta, que yo entiendo que no necesitamos.
Así que esto también me lo voy a saltar, que yo tengo Visual Studio Code y ya está.
Instalación de rast.
La manera recomendada de instalar rast es usar rast app.
Yo creo que lo tengo instalado.
Creo que lo tengo instalado.
Pero bueno, voy a hacerlo como si lo estuviera haciendo de cero.
¿Vale?
Aquí pone rast app.
Is a instalar.
Rast app es como si fuese el nvm.
¿Vale?
Como si fuese un nvm para instalar Node.
Por lo mismo.
Run the following in your terminal.
Y que sigamos las instrucciones.
Bueno, vamos a la terminal.
¿Vale?
Y aquí mismo vamos a hacer esto.
¿Vale?
Proceed with installation.
¿Ves?
Esto es porque ya lo tengo instalado.
Venga, vamos a instalarlo.
Le doy al 1.
Rast install now.
Great.
Para empezar, puedes hacer un restart.
Cierra la pestaña y la vuelves a abrir.
O simplemente puedes ejecutar el comando este.
Este es el comando que aparece aquí al final.
Source cargo env.
Y ya lo deberíamos tener.
Pero bueno, voy a abrir una nueva pestaña.
Voy a cerrar.
Y ahora ya tendríamos que tener rast set.
¿No?
Vale.
Y ahí lo tenemos.
¿Vale?
Ya tenemos rast instalado en nuestra máquina.
Entiendo que esto deberá funcionar bien.
¿Ves?
Porque estoy en Unix.
Si estáis en Windows, tened en cuenta que a lo mejor es un poco más complicado.
Bueno, veo que hay que ejecutar.
Hay que ejecutar un archivo.
Bueno, pues ya lo sabéis.
En Unix será un comando y en Windows, como no, es ejecutar un exe.
Vale.
Rast requiere las herramientas de compilación.
Yo creo que...
Vea los pasos de la unidad anterior.
Para Visual Studio o versiones posteriores.
Yo creo que no lo vamos a necesitar, pero bueno.
Si has instalado rast app en el pasado, puedes actualizar la versión más estable, más reciente, ejecutando rast app update.
Voy a ejecutarlo solo para verlo.
Que no...
¿Vale?
Ya lo tengo.
Así que perfecto.
Comprobación de la instalación de rast.
¿Vale?
Esto ya es justo lo que he hecho.
Mirar la versión.
Mirar cargo versión.
Esto es como la versión de MPM, pero de rast.
¿Vale?
1.56.
Todo bien.
Ambas líneas de la salida contienen la siguiente información, que ya hemos visto aquí bien.
Ya tenemos todo aquí.
¿Veis?
Tenemos aquí como el hash, la fecha, 4 de octubre de 2021.
Comprobación de conocimientos.
¿Cuál es el comando recomendado que se debe usar para instalar rast?
Rast app.
¿Con qué frecuencia se actualizan las bibliotecas de rast?
Yo qué sé.
A ver, eso me lo he saltado.
Vale.
Creo que ya lo he visto.
¿Con qué frecuencia se actualizan las bibliotecas de rast?
Es que, claro, no sé si por bibliotecas...
Yo entiendo que se refiere a rast.
Y creo que son seis semanas.
Vamos a darle.
Vale.
Efectivamente.
Cada seis semanas tenemos una nueva versión de rast.
Esto es porque tiene un ciclo en el que cada mes y medio saca una nueva versión.
Venga, ejercicio.
Hola, mundo.
Oye, qué bien que tengas aquí para elegir tu sistema operativo.
¿Vale?
Esto está muy, muy bien.
Creación de un nuevo directorio para organizar el código.
¿Vale?
Pues vamos a crearlo.
Vamos a crear un nuevo directorio.
Vamos a ir...
Yo lo voy a crear aquí en mi carpeta dev porque es donde lo tengo todo.
Vamos a crear rast learning path.
Rast learning path.
Y una vez estamos aquí dentro, dice que creemos uno que se llame hello world.
¿Vale?
Ya estamos aquí.
Escritura del primer programa con rast.
Vamos a levantar aquí el Visual Studio Code.
Y dice que escribimos un main.rs.
Main.rs.
Y aquí básicamente escribimos otra vez el mismo programa que hemos escrito antes.
Print ln hello world.
Creo que lo he escrito bien.
Si no me he olvidado.
¿Vale?
Más o menos.
Print hello world.
Compilación y ejecución del programa.
¿Vale?
El código fuente está listo.
¿Vale?
Nuestro primer programa con rast.
¿Qué os parece?
Ahora es el momento de compilar el programa en un archivo ejecutable.
¿Ok?
Abro la terminal.
Y en la terminal vamos a poner rast c main.rs.
Este es el compilador.
El compilador no me ha dicho absolutamente nada.
Pero me ha creado aquí un archivo.
¿No?
Como un archivito que además no tiene extensión.
Me imagino que este es el archivo ejecutable.
Y al ser ejecutable ya podríamos hacer punto barra main.
Darle a lente.
Y ahí tenemos hello world.
Bueno, pues hasta ahora.
Bien.
O sea, bien, bien, bien.
Todo ha ido bien.
Así que, bueno, ya tenemos aquí nuestro primer programita.
Sería de la línea de comandos.
Pero bien.
Ya tenemos ahí nuestro hello world.
Vamos a ver si esto es lo que había que hacer.
Ya me siento bien.
Vale.
Este deberá ser siguiente.
Creación de un proyecto con cargo.
Cargo, de nuevo, es el administrador de paquetes de rast.
Es el npm de rast.
Para crear un proyecto con cargo, tenemos que estar en el directorio rast learning path.
Perfecto.
Y ejecutar el siguiente comando.
Cargo new, hello cargo.
Vale.
Voy a volver hacia atrás.
Este es el hello world.
Voy a volver para atrás.
¿Vale?
Me imagino, efectivamente, como dice Milfer, en Windows seguramente compilará directamente un punto Excel.
Lo cual es una ventaja bastante importante.
¿Sabes?
Porque esto lo que hace es que tenéis un ejecutable súper fácil y súper...
Entiendo que a lo mejor se podría...
O sea, se podría configurar que te ponga los ejecutables de cada uno.
No lo sé.
No sé si le podría.
Vale.
Vamos a ver.
Cargo new, hello cargo.
Cargo new, hello cargo.
¿Vale?
Esto es para crear un nuevo proyecto con cargo.
¿Vale?
Nos ha creado ya el hello cargo.
Vamos a ver el S.
Aquí tenemos la carpeta.
Hello cargo.
Hello cargo.
Muy bien.
Y ahora aquí vamos a abrir este proyecto.
Vale.
Esto está ya más interesante, ¿eh?
Porque me ha creado, por un lado, un archivo cargo.toml.
Toml.
Para el que no sepa lo que es toml, básicamente...
Mira, de hecho me dice que si quiero buscar una extensión me vendría bien.
Pero toml es como una extensión, es parecido a jaml, ¿vale?
Es un formato de archivos para configuraciones como json, como jaml y todo esto.
Esto sería un poco la estructura que tiene.
Está bastante interesante.
Mira, es toml's obvious minimal language.
También es sin ningún tipo de llave.
Me sorprende, ¿no?
Teniendo en cuenta que, no sé, que como funciona un poquito Rust, pues utilizar un estilo así.
Pero bueno, está bien.
Al final es muy parecido al json, solo que no necesita llaves.
Es más parecido a jaml, porque también necesitas hacer las tabulaciones.
Y lo que sí que es interesante, y a mí me parece mejor que json, es que tienes tipos de estructuras de datos, ¿vale?
No solo tendrías los strings.
En el json, si recordáis, creo que solo tenéis strings.
Sí que tienes arrays, pero tienen menos, ¿vale?
Pero aquí sí que puedes utilizar, también tienes boleanos en el json, pero bueno, que tienes estructuras de datos, ¿vale?
Por lo general nadie tabula en tom.
Ah, no es obligatorio.
Hostia, pensaba, en jaml sí que es obligatorio.
Pensaba que en toml, pensaba que sí que era obligatorio.
Pues mira, mejor, la verdad.
A mí no me suele gustar mucho, pero entiendo que cuanto menos tabulación tengas, entonces mejor.
Lo bueno y lo malo de jaml es que sí que es obligatorio.
Lo bueno y lo malo.
Vale, search.
Vamos a buscar better toml.
Me imagino que este será una buena, porque tiene un montón aquí de extensiones, de instalaciones.
Este tiene 123.000.
Vale, vamos a instalar este para que nos ayude.
Vale, vamos a darle por aquí, cargo.
Venga, ahora sí que ya tenemos la sintaxis bien vista, ¿vale?
Bueno, ya tenemos este archivo cargo.toml, que entiendo que aquí es donde vamos a tener,
será nuestro package.json, ¿vale?
Para que nos entendamos, yo os voy a poner analogías un poco del desarrollo web.
Y aquí tenemos el nombre del paquete, la versión del paquete, la edición, el año.
Y aquí tendríamos las dependencias que ahora mismo no tiene ninguna.
Nos ha creado un gitignore con una carpeta target.
Aquí entiendo que es donde va a estar las compilaciones, tanto las que sean para perivisualizar
como la de producción, la definitiva.
Entiendo que irá por aquí, que por eso nos lo pone por aquí.
Y una carpeta source.
Me gusta mucho el tener una carpeta source.
Esto es una cosa que me gusta bastante, así que muy bien por ello.
Y aquí tenemos el main.rs, que veo que por ahora todo el código que hemos visto de RAS en una hora es este.
Vamos a ver si ahora nos dicen de hacer algo, ¿vale?
Vale, cargo, o sea, archivo de manifesto y el main.rs, el subdirectorio de SRC, y donde se escribirá el código de la aplicación.
Vale, ahora bien, para diferenciar esto, entiendo que antes hemos utilizado el RAS C este para compilar,
pero ahora vamos a utilizar cargo directamente, ¿vale?
Entonces, entramos en la carpeta y podríamos hacer cargo RAN.
Vale, vamos a entrar en la carpeta, ya estamos aquí, y vamos a hacer cargo RAN.
Lo compila, termina, lo ejecuta.
Y aquí tendríamos la carpeta target, que tenemos la carpeta debug, o sea, lo que decía,
que tendríamos las versiones preliminares de debugging y la de producción, me imagino que también.
Y aparte de todo lo que he hecho aquí, fíjate que aquí está el ejecutable.
Entiendo que este ejecutable, si yo voy a punto, barra, target, debug, barra, e intento ejecutar hello cargo,
va a funcionar también, ¿ves? Aquí lo tienes.
Ahí, ese sería el archivo que es compilado.
¿Vale? Cargo ha compilado y ejecutado el archivo ejecutable.
Enhorabuena, ha escrito... Bueno, es mentira, todavía no hemos escrito a un coño,
porque básicamente esto es lo escrito solo.
Resumen, en este módulo has instalado RAS, las herramientas de Visual Studio Code que necesitas para escribir...
Bueno, a ver, todavía no he instalado ninguna extensión de RAS.
Vamos a ver si hay alguna de RAS.
Hombre, tiene pinta... Fíjate, 1,3 millones de instalaciones.
¡Ostras! La leche.
Pues vamos a instalarlo en esta, ¿no? Que tiene buena pinta.
Este RAS.
Y este, an alternate RAS language server to RLS.
Hmm, interesante este también, ¿no?
O sea, tienes que tener una u otra.
Hmm.
Coño, pero aquí pone...
Sponsor, que la está sponsorizando Mozilla.
¿Y esta de quién es, entonces?
¿Esta de quién es?
Bueno, vamos a instalar...
Vamos a empezar con esta y luego probar la otra, va.
Porque me imagino que a lo mejor la otra es...
Es que tiene muy mala... Es que fíjate, tiene muchas instalaciones, pero tiene como mala puntuación.
Venga, vamos a desinstalarla, vamos a poner la otra.
Me imagino que a ver el...
RAS analyzer es mejor. Vale, vale.
Hay gente aquí en el chat que me está diciendo que utilice la de analyzer.
Pues utilizo la de analyzer.
Ya está.
Vamos a hacer un reload para que se olvide de la otra.
Vale.
Ya se ha instalado la de analyzer.
Vamos aquí.
Bueno, ahora mismo no veo nada diferente.
De hecho...
De hecho, esto...
Ah, mira, pone aquí en run, debug...
Hostia, esto está muy chulo.
Pero esto no se me queja de que no le he puesto el punto y coma.
Eso no se me queja.
A ver, si la vemos en run, debería petar.
Ah, no.
Pensaba que el punto y coma era obligatorio.
Pues ya veo que no.
Vale, fantástico.
Así no escribo puntos y coma.
Me encanta.
Ah, no es obligatorio en la última línea.
Interesante.
Bien, bien.
Bueno, pues hemos aprendido ya.
Hemos instalado Rust, un poquito la herramienta Visual Studio Code.
Hemos creado el hola mundo básico.
Y nada, vamos a seguir ahora con los conceptos de programación más comunes en Rust.
Vamos a desbloquear el logro, que me lo he ganado.
¿Qué tal lo estamos haciendo?
Venga, bien.
Bien, bien, bien.
A ver, no hace falta.
No hace falta que me preguntes tanto.
Oye, pero quiero desbloquearme el logro.
Vale, vamos a crear...
Ostras, esta no está traducida al castellano.
Oh, no está traducida al castellano.
Bueno, no pasa nada.
Yo lo voy traduciendo.
No os preocupéis, ¿vale?
Crea tu primer programa en Rust.
Venga, vamos a crear nuestro primer programa en Rust.
En este módulo vamos a aprender los conceptos de programación más comunes en Rust.
Y, bueno, nos ha dicho ahora el Rust Playground, por si queremos utilizar el Rust Playground.
Vamos a utilizar, en nuestro caso, vamos a evitar utilizar el Playground de Rust,
porque hemos visto que no funciona.
Así que vamos a hacerlo directamente a lo mejor aquí.
Lo podemos hacer aquí mismo, ¿vale?
Vamos a ir creando aquí archivos y lo vamos probando y tal.
Vale, entendiendo la estructura básica de un programa de Rust.
Las funciones en Rust.
Una función es un bloque de código que especifica una tarea, ¿vale?
Esto es muy parecido, al final, a lo que sería cualquier lenguaje de programación, ¿no?
Que separamos el código en diferentes funciones reutilizables.
Cada programa de Rust tiene que tener una función llamada main.
Esto sí que es importante, ¿vale?
Mira, este será el Playground, pero el Playground antes no nos ha funcionado.
No sé si ahora se habrá recuperado, pero antes no nos ha funcionado.
Entonces, tiene que tener una función llamada main.
Ya vemos aquí en el Hello World que teníamos esta de main, así que es cierto que necesita una de main.
El código de main siempre es el primer código que se ejecuta en un programa de Rust.
Y desde aquí tú puedes llamar a otras funciones.
Sería el punto de entrada de tu aplicación de Rust, es este main.
Así que aquí lo tenemos que tener clarísimo.
Para declarar una función en Rust tenemos que utilizar la keyword fn, esto de aquí, de function.
Como esto sigue así, ¿sabéis lo que van haciendo?
Por ejemplo, esto era antes function, luego no sé cómo era fn, fn, luego será f, luego ya será nada, ya será nada directamente.
¿Sabes? Es que cada vez están poniéndolo con más.
Me encanta.
Es fun.
Creo que en Kotlin es fun, ¿no?
O sea, function, creo que era fun, fn.
Van para, van eliminando letras.
Después del nombre de la función, le tenemos que decir al compilador cuántos parámetros o argumentos espera la función recibir como un input.
Y estos argumentos se listan dentro de los paréntesis, muy parecido a como ser en JavaScript.
El cuerpo de la función es el código que hace y estaría aquí.
Vale.
La indentación del código.
Venga, a ver si hay algún tipo de regla o algo que tenemos que tener en cuenta.
En el cuerpo de la función, most, o sea, casi todas las frases, las líneas de código terminan con un semicolon.
Y RAS procesa estas declaraciones una detrás de otra en orden.
Cuando una línea no termina con un semicolon, RAS sabe que la siguiente línea tiene, dice, cuando un código, o sea, cuando no termina con semicolon una línea, RAS sabe que la siguiente línea de código tiene que ser ejecutada antes, hostia, antes de que pueda ser completado.
Bueno, hostia, esto lo tengo que ver un poco en ejemplo porque me deja un poco loco esto.
Para ver cómo funciona la ejecución, bueno, usamos indentación.
Esto es como en todos los programas, ¿vale?
Que usamos la indentación para entender un poco los pasos de una función y si tenemos condicionales y lo que sea, ¿vale?
Dice que utiliza la indentación de cuatro espacios desde la izquierda, ¿vale?
Cuando un código no termina con un semicolon, la siguiente línea que se ejecuta es indentada con cuatro espacios más.
¿Vale?
Cuando no termina con un semicolon, la siguiente línea que se ejecuta es indentada con cuatro espacios más.
Vale, eso es un poco raro, pero bueno, ya veremos.
El todo macro.
Cuando empiezas a trabajar con los módulos de RAS, vas a notar que tienes como un código de ejemplo, que es básicamente el que hemos visto, ¿no?
Un macro en RAS es como una función que toma un nombre variable de argumentos y el todo macro es usado para identificar código que no está terminado en RAS.
El macro sirve como para prototipar o cuando quieres indicar algún comportamiento que todavía no ha sido terminado.
Aquí hay un ejemplo de cómo utilizamos el todo macro en este ejercicio.
Vamos a ver.
O sea, tú lo puedes poner todo y la exclamación.
Y aquí le dices, muestra un mensaje que estamos by using the print, no sé qué, no sé cuánto.
A ver, vamos a ver esto.
Vamos a ejecutarlo.
Run.
A mí esto lo que me ha hecho es que me ha petado.
How we use it to do macro in the exercise.
When you complete the code that uses the to do macro, the compiler can return a panic message.
Claro, pues eso es lo que me nos ha pasado, ¿no?
Just implemented.
Ah.
Dice, a thread main panic has not yet implemented porque todavía no está implementado, ¿no?
Y dice, display del mensaje usando println macro.
O sea, lo que estamos diciendo aquí, pero claro, es que con este pedazo de error que parecía que me había reventado la memoria de hasta a mi coche.
Madre mía, qué miedo.
Bueno, o sea, lo que quiere decir básicamente es que imagínate que tú estás trabajando en algo y dices, bueno, todavía no lo he terminado.
Pues tú le puedes decir aquí un to do, que es que, claro, panic.
Madre mía, qué miedo.
Y le puedes poner aquí el mensaje que quieres que aparezca, ¿no?
Diciendo, bueno, todavía estoy trabajando en ello y tendría que estar haciendo esto, ¿vale?
Entonces, pues nada, podemos hacer esto así y le podríamos quitar esto.
Display the message y ya estaría funcionando.
Es como una función interesante para indicar que todavía estás trabajando en algo y ya está.
Otro macro diferente.
El to do sería como el más básico.
Sería como un console lock, pero que petaría, ¿sabes?
Que al encontrarse eso iría, ¡pam!, fuera, petada.
Es bastante bestia.
Print ln macro.
El print ln macro sería como un console lock sin petar, básicamente.
Este macro, el print ln, espera uno o más argumentos de entrada.
Efectivamente, como un throw.
Lo que pasa es que, claro, un throw error, entiendo que puedes hacer un catch.
Es que en este caso es como que te peta.
No sé si se podrá hacer un catch de esto, pero bueno, parece más que es como que te peta el compilador o que te avise.
Vale.
Pues el print ln sería como el console lock y es exactamente lo mismo, que espera uno o más argumentos de entrada.
Y puedes enseñar, pues nada, en la pantalla o en la salida estándar lo que tú quieras.
En este caso le hemos enseñado un string, pero entiendo que podríamos empezar a sacar otras cosas.
De hecho, aquí tendríamos el tema de hacer sustituciones, ¿vale?
Podemos hacer sustituciones.
Para eso podemos llamar al print ln y le podemos utilizar los curly brackets estos para hacer sustituciones de código.
Entiendo, por lo que he visto así, que sería hola.
Ponemos aquí los curly brackets estos, las llaves, y aquí le podríamos decir hola midu pandilla.
Venga, hola Twitch, ¿no?
Podríamos hacer esto y este valor que estamos poniendo aquí va a ser sustituido aquí.
Claro, esto entiendo que será útil cuando tengamos variables.
Vamos a darle a run, ¿vale?
Y aquí podemos ver hola Twitch.
Entiendo que es esto, hola Twitch, como hoy es.
Y aquí podríamos poner otro, ¿vale?
Entonces va a ser como en orden.
Aquí vamos a tener Twitch y aquí vamos a tener viernes.
¿Vale?
Y así podríamos continuar con números, con lo que sea.
Midu gang, me gusta.
Midu pandilla, ¿me gusta?
Midu pandilla.
Entiendo que también vamos a poder utilizar variables, lo que sea, ¿vale?
Hostia, hostia, no me jodas que tiene charts esto.
Entiendo que esto también puede utilizar charts.
Chart es como un string que solo puede ser de una letra, básicamente.
Tiene que ser un unicode.
Hola, hoy es viernes.
Bueno.
Vale.
Cada instancia de curly brackets, tal, tal, tal.
Bueno, entiendo que esto luego, esto, el curly brackets o las llaves,
es como la forma más sencilla de hacer esto,
pero luego se podrán hacer transformaciones para que la evaluación se pueda hacer de otra forma,
cambiarle el orden.
Entiendo que nos lo enseñará.
¿Cuántas main functions puede haber dentro de un programa de Rast?
Un programa de Rast puede tener tantas main functions como se necesiten.
Eso es verdad, ¿no?
Any function en Rast puede ser una subfunción name main.
Every Rast program must have only one function name main.
Entiendo que esto seguro.
Tiene que tener, es que tener solo una, pero claro, es que a lo mejor puede tener más mains por ahí en otras funciones.
Eso me lo he perdido.
¿Cuál es el keyword?
¿Ves?
Function, func, fun, fn, fn en este caso.
Para crear una función, fn.
¿Cuál es el output de llamar println macro?
¿Vale?
Aquí tendríamos las llaves, dos llaves.
Esto sería uno es number, two es word, uno es number.
Y, hostia, ojo.
A ver, entiendo que sería este.
Es que, claro, no hemos visto si los números se pueden utilizar así.
Entiendo que sí.
Bueno, ya voy a decir que sí.
Vale, todo bien, todo bien.
Todo bien, todo correcto por ahora.
Venga, variables en Rust.
Los desarrolladores pueden escribir programas para trabajar con datos.
Los datos, pues nada, se analizan, se guardan.
Variables, vale, que podemos utilizar variables como en cualquier otro sitio.
En Rust las variables son declaradas con la palabra clave let, muy parecido a JavaScript.
Y cada variable tiene que tener un nombre único.
Cuando una variable es declarada, se le puede asignar un valor,
o el valor se le puede asignar más tarde.
El siguiente código declara una variable llamada a number.
¿Vale?
Let a number.
Y esta variable todavía no tiene un valor.
Aquí lo estamos creando muy parecido a esto, a JavaScript.
Podemos modificar esto para indicarle un valor.
Vale, esto es exactamente lo mismo de siempre.
Son palabras reservadas.
Fn y let son palabras reservadas.
Y solo se pueden utilizar para ello, para esto en Rust.
¿Vale?
No lo puedes, o sea, no puedes poner let fn.
No tendría sentido, petaría.
Vamos a ver otro ejemplo, ¿vale?
Declarar una variable, declarar una variable con un string.
Entiendo que es esto.
Luego, el a number, que es esta primera variable,
luego le ponemos este valor.
Y aquí, pues, hacemos el println que hemos visto antes, ¿vale?
Si llamamos println e intentamos mostrar el valor de a number,
antes de que se le muestre el compilador, se queja.
Venga, vamos a ver eso.
Bueno, aquí nos dice que ya podemos crear aquí un let a number.
Lo creamos así.
Y vamos a intentar mostrar el, vamos a intentar mostrar a number.
Mira, ya de hecho se queja.
Type annotations need to consider giving a number a type.
O sea, dice que quiere saber, claro, no sabe qué tipo es.
Claro, si le damos a run, es que no sabe qué tipo es.
Me imagino que a esto habría que ponerle un tipo, no sé qué tipos hay.
Vamos a ver qué tipos hay.
Y32, ¿vale?
Vale.
Aunque Y32 básicamente es un entero de 32 bits,
no le he puesto un valor, le he puesto un tipo.
Luego veremos los tipos, me imagino.
Pero todavía se queja.
Se queja porque está sin inicializar.
Bueno, ya hemos visto un poco lo de la queja.
Oye, está muy bien, ¿eh?
Es que te lo dice entero por real.
Es como un linter, pero a la vez también compilador.
Esto está muy chulo.
Me gusta, me gusta.
Vale.
Mutable contra inmutable.
En RAS las variables son inmutables por defecto.
¿What?
Cuando una variable es inmutable,
el valor que se le pone después ya no lo puedes cambiar.
O sea, ojo con esto.
O sea, yo le pongo anamber es 2 y digo anamber es 3.
¡Hostia!
No se puede reasignar.
O sea, cuando tú creas una variable let y le asignas un número,
un número o un valor, ¿vale?
Le atas, le asignas un valor.
Luego no puedes reasignarle a esa variable otro valor.
Me imagino que habrá formas de hacer esto, pero bueno,
está interesante.
Si intentamos cambiar el valor de anamber, ¿vale?
Pues recibimos un error, como hemos visto.
Pero para mutar un valor, que es este caso, para mutar un valor,
tenemos que utilizar la keyword mut, ¿vale?
O sea, tenemos que indicarle que queremos mutar ese valor para que se pueda cambiar.
O sea, le tenemos que poner aquí mut, de mutable.
Y de esta forma, ahora sí.
Hostia, pero fíjate, madre mía, madre mía, qué interesante está esto.
Vale, o sea, cuando le pones mut, sí, sí que, ¿vale?
Al ponerle mut, lo que hacemos es que esa variable se puede cambiar,
se le puede reasignar el valor.
Por lo tanto, aquí lo que estamos haciendo es anamber, que tenía el 2,
pues le estamos pasando el 3.
Pero fíjate que me está dando un warning súper interesante que me está diciendo,
oye, es que cuando tú has hecho este, cuando le has asignado el 2,
esto nunca se le está, nunca se está leyendo este valor.
Me está dando un warning como este valor con el número 2 nunca se está leyendo
y aquí lo estás asignando a 3 y entonces lo estás leyendo.
Por lo tanto, lo que estás haciendo aquí es perder el tiempo.
Esto no sirve para nada.
Básicamente es lo que me está diciendo en toda la cara.
Eso es lo que me está diciendo.
Y aquí encima luego me dice, vale, y ahora no necesita ser mutable.
Está muy chulo.
La verdad es que esto es una de las cosas...
Esto está curioso.
Entiendo que si pusiésemos aquí que es mut,
le decimos que esto es el 2, ¿vale?
Ahora se quejará de que no lo hemos usado,
pero si le ponemos el println, lo ponemos justo aquí, entiendo.
¿Ves? Ahora no se queja.
Y de esta forma, si compilo esto, deberíamos ver dos veces el mensaje,
una vez con el número 2 y otra con el número 3.
Está curioso.
Me gusta.
¿Ves?
Ahora sí.
Muy bien, muy bien.
Hostia.
Está bien, pero muchas cosas tened en cuenta ya.
Variable shadowing.
Puedes declarar una nueva variable que utiliza el mismo nombre
de una variable que ya existe.
La nueva declaración crea una nueva...
No sé cómo decir, binding, castellano.
Binding como enlace, ¿no?
Vinculante.
Nuevo enlace.
Enrase esta operación se llama shadowing porque esta nueva variable
como que...
Es como que shadows, como que ensombrece.
Es que ensombrece queda muy raro.
Oscuridad, sí, oscuridad, ¿no?
O sea, es como que se pone por delante, ¿sabes?
Es como que dice, vale, esta variable que todavía has creado
con este nombre, la vamos a dejar de utilizar,
aunque porque has creado una que se llama igual
y la dejamos detrás, ¿sabes?
Es como que ya no puedes utilizarla, se llama igual
y machacamos esta nueva, ya está.
Sombrear queda muy raro, ¿no?
O sea, al final la vieja existe,
pero ya no te puedes referir a ella.
O sea, ya no te puedes referir a ella
porque es como que ha pasado por delante la otra.
El siguiente código demuestra el uso del shadowing,
que declara una variable llamada shadowNum.
Nosotros no definimos la variable como mutable.
Claro, o sea, no define la variable como mutable
porque directamente van a crear una nueva
que se llama igual y que se va a quedar
como por delante de la otra,
pero va a utilizar el mismo valor.
Hostia, esto se puede utilizar tantas veces
como te dé la gana.
O sea, si lo he entendido bien, ¿vale?
Vamos a ver si esto lo he entendido bien.
Básicamente, tú tienes aquí shadowNum, ¿no?
Y le ponemos 42, ¿vale?
Y ahora puedes decir, vale, pues let shadowNum,
por cierto, GihacoPilot funciona también con Rust, ¿vale?
Se desvanece. Me gusta, muy bien.
Me gusta. Se interpone, también sobrepone.
Desvanecer. Eso está, esa me gusta.
Entonces, claro, lo que hace aquí es que...
Ay, que no he puesto el semicolon.
Aquí lo que está pasando es que esta,
esta de aquí es esta,
pero esta es una nueva variable
que ahora queda por encima.
Entiendo que lo que hace automáticamente esta,
no sé si son así los comentarios,
mira, shadowNum es a shadow variable, efectivamente.
Lo que pasa con esta, de esta línea,
entiendo es que la recoge el garbage collector
o algo, alguna cosa, ¿vale?
Alguna cosa hará.
Y esto podemos seguir haciéndolo,
o sea, podemos volver a hacerlo,
multiplicarla por dos,
y aquí println,
y aquí decimos que el valor del shadowNum es,
y a todas estas, pues 43, 86.
Todo esto debería ser 86, entiendo.
Vamos a darle a run, 86, ¿vale?
Muy interesante.
Claro, entiendo que esto lo podemos hacer
porque es un let.
Si más adelante utilizamos otro tipo de forma
de crear la variable,
que creo que también tiene los const,
entiendo que esto no se podría hacer.
Pero bueno, esto es curioso.
Esto no se puede hacer en JavaScript, por ejemplo.
¿Vale?
Venga.
¿Qué declaración de rush,
o sea, qué frase de rush
declara variable y le pone un valor?
Vale, pues esta, ¿no?
Continentes, 7.
¿Cuál es la keyword de rush
que utilizamos para decirle
que una variable se puede cambiar?
Es mut, de mutable.
¿Vale?
Enhorabuena.
Seguimos.
Se está poniendo interesante, ¿eh?
Me está gustando.
Me está gustando.
Me está gustando,
porque estoy entendiendo por ahora.
Venga.
Tipos de datos para números,
texto y booleanos, básicamente.
El rush es un lenguaje
de tipo estático.
Tipado estático.
¿Vale?
Básicamente parecido a como sería TypeScript.
El compilador tiene que saber exactamente
qué tipo de datos tiene todas las variables.
Eso sí,
normalmente lo puede inferir.
Puede inferir los tipos de datos
de la variable que tú le estás pasando.
Por ejemplo,
en este caso le estamos pasando un 42
y está infiriendo que es un entero de 32 bits.
Lo está infiriendo.
O sea, está diciendo,
vale, pues le voy a decir
que es un i32.
Ya está.
Es un entero 32.
Lo mismo,
si yo me empiezo a crear aquí,
yo qué sé,
ponemos aquí
bol,
pues pongo true,
pues, ves,
ya me dice que es del tipo booleano.
Si le digo title
y digo hola,
entiendo que,
hostia,
es un string un poco especial.
Un string,
un string con ampersand,
entiendo que esto es que quiere decir
que es una referencia.
Bueno, bueno,
empezamos ya ahí con cosas raras.
Bueno,
que tiene,
infiere los datos,
lo cual es genial.
Pero,
entiendo que no le puedes cambiar los datos y tal.
O sea,
es totalmente estático.
Bueno,
el próximo,
tienes que informar al compilador
cuando no sabe qué tipos de datos son.
Claro,
por ejemplo,
si tú creas una variable,
por ejemplo,
aquí,
num,
y no le dices nada,
pues no es capaz de inferir el dato.
¿No?
Entonces te dice unknown.
Si quieres que en algún momento,
pues claro,
me imagino que ahora si le dices false,
ahora ya se sabe que es booleano.
Pero lo ideal,
cuando no le metes ahí un valor desde el principio,
no le asignas nada,
sería decirle qué tipo de dato es.
Vale,
en el siguiente ejemplo podemos ver como el compilador,
bueno,
lo que os he explicado,
¿vale?
Todo esto es lo que os he explicado.
Ah,
no,
espérate.
Ah,
bueno,
es porque aquí le está poniendo una u.
Vale,
es lo mismo que os he explicado,
solo que aquí le está poniendo una u.
Le está poniendo una u.
Una u es que no tiene,
no es,
es unsignet,
o sea,
no tiene signo.
Es un,
no es entero,
sino es un número que no tiene signo de 32 bits.
O sea,
no pueden ser,
no pueden ser negativos.
No podría decirle menos 16,
por ejemplo.
Vale,
claro,
dice,
vamos a poner este código.
Entonces,
claro,
si tú le dices u 32 no sé qué,
no sé cuánto,
si yo ahora cambio esto,
pues me va a decir que el tipo de dato
no es correcto.
Me dice,
oye,
es que tú me has dicho que es u 32
y aquí lo que estás intentando poner
es el ampersand string.
O sea,
no está bien el tipo de datos.
¿Vale?
Bueno,
perfecto.
Vale,
nos lo dice el compilador.
Vale,
tipos de datos que tienen,
que tiene,
básicamente,
números enteros,
de coma flotante,
booleanos,
y characters,
¿vale?
Characters,
o sea,
estos son chars,
que no es lo mismo que un string,
¿vale?
Es diferente.
¿Se parece?
Sí,
es lo que dice Juanjo,
se parece,
la verdad,
se parece a un,
se parece a,
se parece a,
coño,
ahora eso,
a Swift,
no me acordaba.
Vale,
tenemos los números,
con enteros y coma flotante,
aquí tendríamos la longitud,
entiendo que 8 bits,
pues tendríamos,
de 8 bits,
cuántos números se pueden hacer,
pues los que,
los que quepan,
esto es,
depende de si los tienes con signo o sin signo,
si es con signo,
pues son la mitad de los que puedes hacer sin signo,
lo bueno de los sin signo,
bueno,
pues si solo son positivos,
pues al final puedes aprovechar ese,
los que no necesitas de negativo para eso,
claro,
esto lo hacen justamente un poco para,
para intentar optimizar al máximo la memoria,
el uso de la memoria,
si por ejemplo,
tú quieres decir la edad que tiene una persona,
pues seguramente no tiene sentido que hagas uno de 128,
bits,
¿vale?
Porque el número máximo será un montón,
entonces tú aquí le dirías,
pues no quiero que tenga signo y que sea 18 y su edad,
pues es 18,
18,
¿vale?
18,
y no podrás poner un número muy grande porque seguramente,
¿ves?
Esto está fuera del rango,
que va hasta 255,
pero no hay nadie,
en su sano juicio,
que dure 255 años,
¿verdad?
Pues eso,
esto sería para el age,
tendría sentido para el age poner un U8,
¿vale?
18,
que es mierda.
En un número cuenta como un bit más,
efectivamente,
claro,
el U18,
pues aquí tendríamos 256,
¿no?
255 sería el máximo,
hostia,
ahora por qué no,
ah,
porque aquí,
claro,
peta el compilador primero,
¿ves?
Esto sea hasta 255,
si le ponemos que tenga signo,
y le ponemos aquí un número chungo,
pues nos va a decir que llega hasta la mitad,
¿vale?
Es un bit menos,
y por lo tanto puede generar la mitad de números,
el rango es más pequeñito,
¿vale?
Bueno,
esto es básicamente lo que os he comentado,
obviamente,
para 64 bits,
32 bits,
todo esto,
RAS tiene dos tipos de coma flotante,
los valores de 32 bits,
y los de 64,
pero,
la que es por defecto,
es el de 64,
en las CPUs modernas,
el tipo de 64,
es de la misma velocidad que 32,
pero tiene mejor precisión,
hostia,
es curioso esto,
¿no?
O sea,
por defecto,
va a inferir que el 4.0,
es de 64 bits,
¿vale?
Todos los números primitivos en RAS,
soportan operaciones matemáticas,
solo faltaba,
hostia,
fíjate,
para indicar que un número,
directamente,
cuando estás,
pero,
entiendo que esto,
por defecto,
¿ves?
Es lo que está diciendo aquí,
la sintaxis,
1,
U32,
lo que le dice al compilador,
es que el valor,
es el número 1,
y lo tiene que interpretar como,
un entero,
no,
que no tiene signo de 32 bits,
¿vale?
Por defecto,
le asigna el I32,
cuando ponemos el número normal.
Saludos,
Midu.
Hola.
Acabo de descubrir tu contenido,
y estoy fascinado.
Eres un crack.
Qué guapo.
Muchas gracias,
hombre.
Más majo.
Muchas gracias.
Gracias de corazón.
Vale,
los boleanos,
que entiendo que esto,
no hay nada que explicar,
de los boleanos,
carácteres y strings,
¿vale?
RAS soporta valores de texto,
dos tipos de texto.
Un carácter es un solo carácter,
¿vale?
Es un solo item,
o sea,
un carácter,
y se pone con las comillas simples.
Esto es diferente a como en JavaScript,
los strings pueden ser comilla doble,
comilla simple.
Y el char es el tipo más primitivo,
de los tipos de texto,
que al final solo puede ser uno,
¿vale?
Solo puede ser uno.
Aunque puede ser un emoji,
porque pueden ser representaciones de UTF8.
O sea,
podemos ponerle aquí,
a ver,
vamos a ver esto,
let emoji,
le ponemos aquí carita,
mira,
emoji de la caca,
println,
y le vamos a poner emoji to string.
Hostia,
pensaba que esto,
esto es lo que quería hacer.
Y entiendo que con esto,
deberíamos ver el emoji.
Fíjate,
aquí tenemos el emoji.
O sea,
un char puede ser un emoji.
Tiene que ser una representación de UTF8.
Algunos lenguajes que lo tratan,
bueno,
yo creo que esto no es muy interesante.
Vale,
strings.
Este sí que es interesante,
porque los strings es uno de los tipos de datos más importantes,
seguramente,
que existen,
y de los más peligrosos.
El tipo string,
también conocido como string slice,
es una vista a un string de datos.
Ojo con esto,
hay una diferenciación entre string y el string,
o sea,
un trozo de string y un string de datos.
La mayoría del tiempo,
nos referimos a estos tipos usando la sintaxis de referencia,
que precede al tipo con el ampersand.
Cuando tenemos un ampersand en este tipo de lenguajes,
lo que quiere decir es que es una referencia,
¿vale?
Aunque ya nos hablarán de las referencias en el siguiente módulo,
¿vale?
Por ahora vamos a pensar que un string,
¿vale?
Con el ampersand,
que es de referencia,
es un puntero a un tipo de datos de string,
una cadena de texto inmutable.
Súper importante.
Esto tiene pinta de ser de lo peligroso,
¿no?
Todos los string literas son del tipo ampersand string.
Aunque los strings literas son convenientes para utilizar en ejemplos introductorios de RAS,
no son muy,
o sea,
claro,
no se pueden utilizar para cualquier situación cuando queremos utilizar texto,
porque no todos los textos pueden ser conocidos en tiempo de compilación.
Entiendo que,
¿qué pasa?
Al ser inmutables los que creamos por defecto,
¿no?
Al crear,
por ejemplo,
si yo pongo title y ponemos aquí hola,
este string,
al ser inmutable,
lo que quiere decir es que no le podríamos concatenar nada,
¿ok?
Así que entiendo que por eso hay que estar como manejar los dos tipos de datos distintos.
Uno,
el que sería inmutable es el que se infiere por defecto,
y otro,
el string que sí que sería el que se puede manipular.
Por eso RAS tiene un segundo tipo de string llamado string,
que este sí que se,
on the heap,
o sea,
este sí que se,
se está en memoria,
y cuando lo utilizas no necesitas saber cuál es el,
cuál es la longitud del string,
el número de carácteres que tiene el string.
Y además,
antes de que sea compilado.
O sea,
que podríamos concatenarlo,
lo podríamos ir cambiando,
¿vale?
Vale,
si eres familiar con el garbage collected language,
te estarás preguntando por qué tiene dos tipos de string.
La verdad es que yo me estuve explicando esto.
String son,
bueno,
tiene toda la razón en esto que dice,
¿vale?
Las cadenas de texto son tipos de datos.
Os voy a decir una cosa,
voy a decir una cosa antes de continuar.
Voy a decir una cosa,
de una cosa que me está gustando mucho.
Hay una cosa que veo muy interesante de RAS,
si eres desarrollador o desarrolladora de JavaScript,
de TypeScript,
una cosa que yo,
por ejemplo,
me está sirviendo mucho para,
para como volver a recordar muchas de las cosas que aprendí en la
universidad,
y seguramente hay cosas que me van a costar y tal.
Pero una cosa que veo que me gusta mucho es que me va a ayudar a recordar un poco cómo funcionan realmente los lenguajes de bajo nivel y tener que entender cómo funcionan las cosas por detrás.
Ya sabéis,
el que me conozca,
que yo soy un amante de conocer cómo las cosas funcionan por detrás.
Porque si tú no sabes cómo funciona algo por detrás,
al final,
uno,
no entenderás algunas soluciones,
no entenderás dónde están algunos problemas,
y al final realmente no entenderás lo que está pasando.
No serás capaz de determinar si lo que está pasando por detrás es que hay un conejo moviendo unos hilos,
un enano verde,
yo que sé,
lo que sea.
Entonces,
yo creo que siempre que quieras subir de nivel,
entender cómo funcionan las cosas es lo mejor,
lo mejor.
¿Y por qué te digo toda esta chapa?
Bueno,
porque ahora mismo todo lo que estoy leyendo,
¿no?
El cómo se maneja la memoria,
cómo se hace,
pues estamos hablando de punteros,
¿por qué es complicado una estructura de datos de cadenas de texto?
Pues claro,
con esto,
con Rust,
pues ya ves que lo estamos como volviendo a tener que aprender,
al menos yo ya esto lo vi en la universidad hace tiempo,
pero no me acuerdo de casi nada.
Así que me parece muy interesante y te recomiendo mucho,
por eso me parece un poco interesante todo esto,
¿vale?
Total,
muchos lenguajes,
pues bueno,
pasan de esta complejidad,
porque básicamente tienen algún tema de alguna cosa para evitarlo,
pero Rust,
como es un lenguaje de sistema,
pues expone toda esta complejidad de los strings al código.
Ahora,
claro,
con esta complejidad añadida,
viene la posibilidad de controlar de forma mucho más granular
cómo utilizar la memoria,
porque es que los strings pueden ser,
los strings tienen mil millones de problemas de memory leaks,
entonces en este caso entiendo que lo puedes controlar mucho mejor.
Hostia,
dice que hay más de dos tipos de strings,
en realidad,
dice que en realidad hay más de dos tipos de strings,
pero que solo vamos a conocer el string,
así como mayúscula,
y el string,
así como el ampersand,
que es la referencia y tal.
Bueno,
al menos nos quedamos con dos por ahora,
¿vale?
Ahora más o menos,
más o menos conocemos un poco la idea,
¿vale?
Hasta ahora puedes pensar como string,
un tipo de datos que tiene texto,
y que lo puedes cambiar cuando se ejecuta el programa,
y el otro,
el str,
es una referencia con una cadena de texto que es inmutable,
y que no cambia cuando el programa se ejecute.
Dice,
era complicado en los 70,
hoy suena complicado,
pero que parece más pro.
Bueno,
complicado,
lo dice,
complicado en el sentido,
aparte de una persona que no esté habituada,
puede ser complicado enfrentarse a esto,
pero por otro lado,
es complicado en el cómo lo haces de forma efectiva,
de hecho,
si está haciendo esto es porque es complicado,
de hecho,
el hecho que lo haga automáticamente el lenguaje por ti,
y tener un consumo de memoria ideal,
puede ser difícil,
puede ser un reto,
de hecho,
si no lo haría todo el mundo.
Vale,
ejemplos,
¿vale?
¿Cómo usar char str?
Dos cadenas de gavos de char and stations,
bueno,
en este caso,
pues nada,
el tipo de char,
SS,
compile and interpret a single item,
¿vale?
Cuando le ponemos la comilla simple,
entiende que es un char,
¿vale?
Cuando le ponemos comilla doble,
entiende que es un str,
str con el pointer,
o sea,
una cadena de texto inmutable,
en este caso es lo mismo,
estos dos están creando lo mismo,
¿vale?
Aquí tenemos un println,
ahí super bestia,
vamos a chequear mi knowledge,
a ver qué tal,
¿vale?
¿Qué frase describe cómo los enteros,
los números enteros,
son definidos en RAS?
Los enteros en RAS son definidos normalmente con su bit size 8,
16 y tal,
¿vale?
Los enteros en RAS son identificados por su bit size y la propiedad del signo,
esta es la correcta.
Positive o negative integer pueden ser definidos,
yo entiendo que el correcto es el del medio,
¿no?
Vale.
¿Qué frase describe correctamente cómo RAS soporta los valores de los carácteres?
RAS tiene un tipo de dato que puede ser utilizado tanto para carácteres de un solo carácter y multicarácter.
Esto no es verdad.
Esto ya hemos visto que tiene,
esto no lo tiene JavaScript,
no hay algo parecido en JavaScript,
porque en JavaScript tendríamos strings de un carácter.
Pero aquí lo que tenemos es que tiene un tipo de dato que es para un solo carácter.
Carácter chart solo puede ser utilizado...
¿Cómo?
Entiendo esto.
En RAS todos los tipos de texto son representaciones de UTF-8 válidas.
Esto no es correcto, ¿vale?
Porque se puede utilizar un emoji, por ejemplo.
Bueno, vamos a probar a ver.
Vale.
Bien.
Seguimos.
Seguimos.
Definir colecciones de datos utilizando tuplas y structs.
¡Buf!
En esta unidad vamos a explorar estos dos tipos de datos.
Las tuplas.
Las tuplas son un grupo de valores de diferentes tipos
que se coleccionan en un solo valor compuesto.
Estos valores individuales en una tupla son llamados elementos.
Veo que una tupla parece como un array,
pero no exactamente.
Parece como un array de diferentes tipos.
A ver, a ver.
Los valores se pueden especificar como...
Como con paréntesis y cada valor separado por coma.
Las tuplas tienen una longitud fija.
Que es igual al número de elementos que tiene.
Después de que una tupla es declarada,
no puede hacerse ni más grande ni más pequeña.
O sea, no penséis en los arrays de JavaScript.
Es diferente.
Los elementos no se pueden añadir ni quitar.
O sea, que es más parecido a las tuplas de TypeScript.
Más parecido, pero tampoco exactamente.
Es un poco raro, ¿eh?
O sea, si lo comparamos con otro tipo de tuplas que conocemos en el desarrollo web.
El tipo de dato de una tupla es definido en la secuencia de tipos.
Vale.
O sea, crear una tupla es bastante sencillo.
O sea, tú le pones aquí tuple, creas, empiezas con una paréntesis
y le dices aquí, pues este es first element.
Aquí teníamos el número 2.
Aquí podríamos ponerle un true.
Aquí le podríamos poner 4.5, ¿no?
Y aquí podemos ver como la tupla ya va diciendo cada uno de los elementos.
Dice, vale, el primer elemento es un string inmutable.
El segundo es un entero de 32 bits que tiene signo.
El segundo, el tercer un boleano.
El cuarto, no.
Según el elemento, va infiriendo.
Lo que pasa es que esto es la tupla.
O sea, esto ahora ya no lo puedes ni hacer más grande ni más pequeñito.
Esto es lo que hay.
¿Vale?
Aquí sería, ese sería el tema.
Ahora, ¿cómo acceder los elementos de una tupla?
¿Vale?
Para acceder los elementos de una tupla, lo que tenemos que hacer es tuple o tupla 0.
Y aquí tendríamos, mira, lo vamos a ver mejor así.
Lo vamos a ver mejor así.
Elemento, ¿no?
Esto para el primer elemento tenemos que hacer tupla.0.
Y esto, lo que deberíamos ver aquí, elemento, o voy a poner aquí primer elemento.
Aquí deberíamos ver primer elemento, dos puntos, first element.
¿Vale?
Así que le vamos a dar al run.
Primer elemento, first element.
Que queremos acceder al último elemento.
Bueno, pues lo mismo.
Tenemos que ver último elemento.
Bueno, esto no sé si va a funcionar.
Un, dos, tres, cuatro.
No sé si va a funcionar.
Porque a lo mejor el println, esto no me lo va a formatear bien.
No sé, vamos a probar.
Ah, pues sí, 4.5.
Vale, genial.
Pues ya está.
Ya sabemos cómo acceder a los elementos de una tupla.
¿Vale?
Las tuplas son útiles cuando quieres combinar diferentes tipos en un solo valor.
Las funciones pueden usar tuplas para devolver múltiples valores porque las tuplas pueden tener diferentes números de valores.
Claro, esto es muy interesante al hacer un return de tú puedes devolver una función, una tupla en la que es algo parecido a un objeto, ¿no?
Pero un poquito más, bueno, sí, podría ser un poco parecido a un objeto.
Lo que pasa es que no, o me da la sensación que no puedes determinar, no sé si puedes poner, ¿sabes?
No sé si podría decir name igual.
No sé si se puede hacer así, ¿sabes?
No, no se puede.
Ya sería brutal.
Sabes de ponerle al menos una key a la tupla.
No se puede.
Pero bueno, no pasa nada.
Veremos que seguro que hay otro tipo de estructura.
Al final, pues por ahora solo se puede acceder por el índice.
Veremos si nos dicen de otra forma hacerlo.
Bueno, claro, te hayan structs.
Este es el tema, structs.
Los structs es un tipo que está compuesto por otros tipos.
Son elementos, los structs parece que es lo más parecido a un objeto, ¿vale?
Los elementos en un structs son llamados campos.
Como las tuplas, los campos son structs, pueden tener diferentes tipos de datos.
Un beneficio bastante significativo del tipo de structs es que puedes ponerle un nombre, ¿vale?
Que es justamente lo que decía yo, que digo, hostia, si se pudiera poner un nombre ya sería la hostia.
Vale, pero en los structs sí que se puede poner un nombre a cada uno de los campos.
Esto sí que sería un poco más parecido.
A los structs de C, esto sería, me imagino, más parecido a los structs de...
Bueno, de hecho, por aquí...
Ah, es que hay diferentes...
Bueno, bueno, es que tiene tres diferentes de structs, la madre que los parió.
Vale, vale, vamos a verlo, vamos a verlo.
Para trabajar con structs tienes que definir primero el nombre del struct y después decirle el tipo de datos de cada uno de los campos.
Entonces creas una instancia con otro nombre y entonces declara la instancia y los valores que tienes.
Vale, vale, hay tres formas de utilizarlo.
Los structs clásicos, más parecidos a los de C, donde cada campo tiene un nombre y el tipo de dato, que entiendo que es este, ¿vale?
Que es un poco más parecido, este sea un poco más parecido a los objetos, que ese es el que a mí me gusta.
Lo que es genial es que puedes acceder luego a, por ejemplo, student.name y te daría el nombre, el valor de ese campo.
Luego tienes los tipos de tupla, que son similares a las structs con el nombre del campo, pero los campos no tienen nombre.
O sea, pues sería como mezclar las dos cosas, como las tuplas que acabamos de ver, pero, bueno, sin ponerle nombre.
O sea, es interesante.
Podríamos poner aquí struct y decir aquí midu dev, midu, uy, struct, midu, midu redes, ¿no?
Y directamente aquí ya tendríamos que decirle que es todo, pues, son string, string, string y tendríamos, pues, tres strings y ya está.
Pero no le diríamos cómo acceder a cada uno de ellos.
Si queremos decir, vale, pues, este es Twitch, pues, lo podríamos hacer así, Twitch, YouTube o Twitter, ¿vale?
Pues, lo haríamos así, de esta forma, pam, pam, pam, pam.
Ay, pues, así no sería.
Ah, porque no hay que ponerle esto.
Hostia, hostia, hostia.
Qué cosita, ¿eh?
Qué cosita.
Vale, pues, esto.
Esta sería la otra forma.
Y luego la última, que es como vacía, que se utilizan como marcadores, que sabremos más sobre esto, por qué son útiles cuando sepamos sobre los traits, ¿vale?
Esta es bastante curiosa porque es una unidad o struct unit, ¿vale?
Definir un struct.
Bueno, ya hemos visto, hay que utilizar la keyword struct.
Hay que elegir el nombre y el nombre tiene que estar capitalizado, como las clases, ¿no?
De, de, de, de JavaScript que se utilizan clases, pues, aquí lo mismo.
O sea, esto sería, vamos a utilizar un struct más en condiciones, ¿no?
Name, el age sería, por ejemplo, un i8, bueno, u8 y el Twitter, vamos a poner esto, pues, esto sería así.
Trilling semicolon.
Ah, mira.
O sea, cuando haces un struct no es necesario poner un semicolon al final, ¿vale?
Esto sería para crear un struct.
Lo que pasa es que se está quejando porque nunca lo estábamos utilizando.
Dice que este código está muerto.
Qué fuerte, ¿vale?
Esto sería el struct clásico.
El que acabamos de crear sería el struct clásico.
De hecho, bueno, aquí tiene el remote.
Bueno, remote me gusta.
Vamos a poner remote boleana, ¿vale?
Luego, la tupla.
Vamos a crear aquí la tupla.
Struck, ¿cómo le podemos llamar a esto?
Hobbies, ¿no?
Y tendríamos aquí la tupla, sería string, string, string.
Es curioso.
Hay una cosa que me choca sobre la clásica y la tupla.
Y es que la clásica no necesita punto y coma final, pero la que es de tipo tupla, que va como en paréntesis,
sí que necesita el punto semicolon, punto y coma final.
Curioso, ¿eh?
Vale, para instanciar un struct.
Vamos a instanciar nuestro primer struct.
Lo que hay que hacer es crear aquí let persona.
Le tendríamos que decir que es del tipo persona.
Ah, pues no hace falta decirle que es del tipo persona.
Lo puedo inferir.
Y le decimos persona.
Utilizamos las llaves y ahora le tenemos que decir nombre.
Y aquí pone que tenemos que hacer string, dos puntos, from.
Vale, entiendo que es esto lo que quiere decir.
Vale, el string, dos puntos, from, es esto de convertir un string literal a un tipo de string.
Vale, porque claro, es que como lo explican al revés, es un poco raro.
Vale, pero entiendo que es esto.
El string, este método, lo está recuperando del estándar, de la librería estándar, ¿vale?
Los dos puntos lo que quiere decir es acceder a un método que está dentro del string.
En este caso, from.
Y aquí lo que estaríamos haciendo es pasarle una cadena de texto que es inmutable.
O sea, que lo que estamos creando es de una cadena de texto inmutable, estamos creando una del tipo string.
De string así, como este tipo de string.
Entonces aquí, si yo pongo Miguel, lo que estamos haciendo es justamente pasarle el name que es el que necesita.
Claro, si yo aquí lo hubiera puesto, que es una cadena de texto así inmutable, al final, claro que le podría haber puesto aquí Miguel y ya está.
Me podría haber olvidado.
Pero entiendo que lo correcto justamente es poner esta, ¿vale?
Luego, además, aquí ya te va avisando y dice, oye, que te falta el age, el twitter y el remote.
Muy bien, ¿eh?
El remote, vamos a poner que es true.
El age, vamos a poner que tengo 25 años.
Y el twitter, vamos, hay que hacer lo mismo.
String, dos puntos, dos puntos, from.
Ese no es mi twitter, es este.
Qué tascola.
Ahí está.
Y ponemos punto y coma.
Con esto estaríamos creando, oye, pero sí, sí que estoy creando el persona.
Ah, vale, que se me está quejando.
Hostia, joder, ¿cómo llega?
La madre que lo parió.
Fíjate cómo se pasa, mira.
O sea, ahora se queja menos porque ahora sí que estoy utilizando el de persona.
Pero me dice, oye, pero es que no estás leyendo, nunca estás leyendo estos campos, madre mía, ¿sabes?
O sea, te está diciendo, es que nunca has leído el persona, o sea, nunca has hecho, me imagino que aquí podríamos poner persona, persona y empezar aquí, persona.name, persona.name.
Vale, y entonces empezará a quejarse menos.
Pero ves, ahora la persona no se queja, pero dice, ya, pero la edad no la usa.
Persona con edad, entonces hay que hacer persona.edge.
O sea, se queja incluso.
Persona.edge, perdón.
Ahora sí, no.
Persona.edge, never use.
Formatting, specifier, missing.
Vale, esto entiendo que nos lo enseñarán porque, claro, ah, no, es porque no pues aquí tapo nada.
Ahora sí, ahora sí.
Vale, pero nada, que se sigue quejando.
Entiendo que el compilador, aquí podemos ver todo lo, hostia, hostia, todos los warnings.
Tú imagínate aquí todo el día, todo el día viendo warnings.
Es que variable no usada, tuplea, campo no sé qué.
Esto es lo que hace, básicamente, el que sea tan pejiguero es lo que hace que sea tan óptimo en tema de web, ¿sabes?
O sea, en tema de web, en tema de memoria.
En tema de que la memoria la amenaje Superbión, ¿sabes?
De que al final está todo el rato diciendo, oye, pero esto no lo usas, oye, pero esto no lo usas, ¿sabes?
O sea, que yo he venido aquí a optimizar procesos, no a que hagas lo que te dé la gana, ¿vale?
Entonces, claro, aquí se puede ver cómo tienes que utilizarlo todo o se queja.
Esto es lo de convertir, en literal, la cadena de texto inmutable a un tipo string, que es el que nos comentaba, ¿vale?
String, dos puntos, dos puntos, from.
Es un poco raro, hostia, esto va a costar.
Creo que hay otros lenguajes de programación que utilizan lo de los dos puntos.
Pero como estoy tan acostumbrado a lo de los puntos, ¿vale?
Nos dice que también podemos utilizar el punto toString.
Pero dice, en nuestro ejemplo, vamos a utilizar el string dos puntos, dos puntos, from.
Me entiendo que el punto toString debe ser que es menos recomendable a día de hoy, o algo.
Me entiendo, porque en este caso, no sé, a lo mejor esto es algo histórico, o tiene sentido, pero queda más feo, no sé.
Vale, ¿qué es una tupla en Rust?
Una tupla es una colación de valores de diferentes tipos.
Los datos de los tipos están basados en los tipos de datos de sus elementos.
Y la longitud es fija basada en el número de elementos.
Esta tiene buena pinta, ¿vale?
Esta dice que puede hacerse más grande o pequeña.
Esto no puede ser.
Ya hemos visto que las tuplas son fijas, así que no, no, no me engañas.
Ah, eso, en PHP con los métodos estáticos, si no recuerdo mal.
Muy bien, es swap Uruguay.
Perfecto.
Ambos son igualmente válidos.
Ya, bueno, puede ser.
Lo que pasa es que me sorprende, ¿no?
Que diga, oye, no, nosotros vamos a utilizar esta.
Bueno, un poco raro.
Bueno, ¿cuál es la diferencia entre las structs clásicas y las tuple structs?
Bueno, es el nombre.
Ya hemos visto que era el nombre.
Todos los campos en la clase struct tienen que tener el mismo, esto no es verdad, dice
que tiene que tener el mismo tipo de datos, esto no es verdad.
Los valores en una tuple struct pueden ser accedidas usando indexación.
Y en la clase struct pueden ser accedidas solo con el nombre del campo.
Cada campo de una clase struct tiene un nombre y un tipo de datos.
Los campos en un tuple struct no tienen nombres.
Pues creo que es esta, ¿no?
Vale, vamos a mirar una cosa.
Vamos a mirar una cosa.
Si yo pongo aquí persona 0.
No field.
O sea que entonces es esta, ¿no?
Los valores en una tuple struct pueden ser accedidas usando el index.
Los valores en una classic struct can be accessed only by file fill name.
Yo entonces entiendo que es este.
Porque, a ver, es que el de abajo también es verdad.
¿Sabes?
El de abajo también es verdad.
Cada campo en un classic struct tiene un nombre y un tipo de datos.
Y los campos en un tuple struct no tienen nombres.
Esto es verdad.
Pero esto también es verdad.
Los valores en una tuple struct pueden ser accedidas.
Ah, no.
Esto está mal.
Bueno, tuple.
Ah, no.
Está bien.
Los valores en una clase struct can be accessed only by file name.
¿Soy yo o las dos son iguales?
O sea, quiero decir, tuple struct.
No está al revés porque la tuple struct, que son accedidas solo usando el index.
El index es el número y es esta.
Esta es la tuple struct y esto solo puede ser accedido a través del índice.
Tuple struct.
Y luego dice, los valores en una clase que esto puede ser accedida solo por el nombre de usuario.
No, pero he visto que no funciona.
Mira, aquí lo he puesto.
Persona cero y te dice que no accede.
Pero si me dice que no.
Mira, me dice persona cero funciona.
Pero si aquí me dice que no, me dice mira cero.
Dice, no hay campo cero en el tipo persona.
Los campos disponibles son nombres, no sé qué, no sé cuánto.
Lo he probado y no funciona.
Es que los dos me parecen que están bien.
¿Cuál es la diferencia?
Ah, sí, hombre.
Es que así.
No, mentira.
Mentira.
Hostia, no sé.
A ver, entiendo que la diferencia básica es esta.
Entiendo que la básica es esta.
Es la última.
Pero me sorprende la del medio porque, bueno, yo he entendido, la he entendido.
Bueno, las classic struct no pueden ser accedidas con el nombre o no tienen, claro.
Ya, ya, efectivamente.
A mí me funciona.
Ya, pues mira, a mí no me funciona.
Bueno, lo hemos hecho bien.
Siguiente.
Vamos con la siguiente.
Usar enums variants para datos compuestos.
Los enums son tipos que pueden tener...
Pueden ser diferentes variantes.
Lo...
Ras llama enums a...
Algebraic datatypes.
O sea, enums.
O sea, tienes truques.
Truques, tuplas y enums.
O sea, enums es más parecido a lo que tendríamos en TypeScript.
El importante detalle es que cada variante de enum puede tener datos con él.
Utilizamos enum, la palabra clave, para crear un enum.
Bueno, aquí veríamos enum.
Web event.
Una variante de enum puede ser una estructura de unit sin campos.
Claro, o sea, puede utilizar struques.
Al final puede tener struques.
Al final, este no tendría nada asociado, ningún dato asociado a él.
En este caso sí que tendría dos campos.
Uno que sería string y otro una letra.
Y esto sería como el struque clásico que tendría como el objeto, ¿vale?
Con campos y tal.
Definimos los strings con las variantes similares como definimos los diferentes tipos de struques, ¿vale?
Efectivamente, es que parecen struques, es lo que hay aquí, ¿no?
El de unitario este que no tiene nada definido.
El de tipo tupla y el de tipo clásico.
¿Vale?
Cada variante no es su propio tipo.
Cualquier función que usa una variante de web event enum tiene que aceptar todas las variantes de enum.
O sea, si tú aceptas el web event como tipo, tienes que aceptar o esta, o esta, o esta.
Tienes que aceptarlas todas.
No podemos tener una función que solo acepta un clic, o sea, esta, pero no acepta sus variantes.
¿Vale?
Uf.
Uf.
Tela, ¿eh?
Definir un enum con struques.
¿Vale?
Bueno, esto sea el ejemplo parecido al de arriba, ¿no?
Bueno, tendríamos un struque, que este sería del tipo tupla, ¿vale?
Que tenemos un string un char.
Este es el clásico con x, y, y luego tenemos un enum que le decimos que, ah, pero este sí que tiene, este sí que tiene aquí valor, ¿no?
Si hemos cargado con el valor booleano, o sea, esto sería una tupla, clásico, no, tupla, un struque tupla, joder, ¿vale?
Esto sería wiclick con el mouse click, o sea, sería la clásica y esta sería la de la tupla.
Instanciar un enum.
Ahora vamos a añadir algún código para crear una instancia de un enum.
Para cada variante vamos a utilizar el let keyword para hacer no sé qué, no sé cuánto.
¿Vale?
Vale, vamos a crear este enum, un poquito, vamos a ponerlo por aquí, vamos a ponerlo por aquí, vamos a ver si todo funciona bien.
Me imagino que se va a quejar de que no estamos usando nada, código muerto y todo esto.
Entonces, para crear un enum, we load, y aquí ahora tendríamos el web event, que es este, y le decimos dos puntos, dos puntos, we load, ¿vale?
Y aquí le deberíamos decir, como se tiene que pasar un booleano, le podríamos decir que esto es true, punto, y ya está, ¿vale?
Ahora lo que estamos haciendo es, de este enum, estamos accediendo a este de aquí, ¿vale?
A esta variante y le estamos pasando el valor true.
O sea, que esto es un tipo de dato que tenemos aquí ahora en el we load.
O sea, el we load es del tipo web event, que es de este enum, joder, la verdad es que tela, ¿eh?
El ejemplo es un poco tela, se han pasado un poco.
Del web event y tenemos un tipo de dato que es we load y es de valor true.
A ver, esto tiene bastante sentido cuando es un tipo de datos bastante complejos, ¿vale?
Porque de esta forma puede funcionar, pero joder, no está mal.
Una variante, vale, aquí hemos creado una variante.
Podríamos ir creando por aquí.
Aquí lo que podríamos hacer, por ejemplo, sería hacer let click, mouse click, creamos un click, ¿vale?
Y le decimos que tenemos aquí como en la X, en el punto 10 y en el 20, ¿vale?
Y ahora lo que podríamos crear utilizando esto sería we click, por ejemplo, y tendríamos aquí que utilizar el, claro, esto lo he creado aquí arriba, esto no tiene sentido aquí arriba.
Vamos a ponerlo después del enum, ¿vale?
Vamos a ponerlo aquí.
Ponemos let we click.
Daríamos web event, dos puntos, we click.
Y le pasaríamos el click, ¿vale?
Esto lo teníamos así.
O sea, le estoy pasando este click que está utilizando el stroke del mouse click, donde le estamos pasando justamente la X y la Y y con este click lo tendríamos aquí.
Ahora este we click tiene del enum web event, we click, que tiene el valor del mouse click que le hemos pasado arriba.
Y el we keys, ¿no?
Que sea web event, le podríamos pasar we, we, we, we.
Keys.
Y aquí, pues lo mismo.
Tendríamos que crear aquí las keys que han sido presionadas.
Le podríamos pasar keypress con un string que sea midu.
Y aquí, pues, una carita, por ejemplo, ¿no?
Como esto tiene que ser un char.
Bueno, a ver, esto tendría que ser la U.
En realidad, lo correcto sería decir que es la U.
¿Vale?
Variant is never constructed we click.
Vale.
Y ahora aquí en we keys tendríamos el keys.
Y ya está.
Uf.
No está mal, no está mal.
Bueno, pero hemos utilizado todos los enums que teníamos aquí, utilizando todos los structs.
Bueno, la verdad es que como ejercicio ha estado interesante.
Me gusta, me gusta.
Tuple variant.
We keys.
Bueno, este es el que quería.
Ah, mira, string.
Esto sería como para hacer control más lo que sea.
Claro, yo he puesto aquí midu porque me he inventado esto.
Pero sí, esto sería control N, ¿no?
Y esto serían las keys.
Keys new file, por decir algo.
Keys new file.
Vale.
Fíjate cuando utilizamos una nueva sintaxis en este código.
String 2.button from.
Pero esto ya lo hemos, dice, utilizamos una nueva sintaxis.
Pero esta sintaxis ya la hemos utilizado antes.
¿No?
La hemos utilizado antes para crear de una cadena de texto inmutable.
Hmm.
Vale.
Ejemplo de nums.
Y este es el código final.
Bueno, código final.
Ah, mira, voy a copiarme el print este.
Y vamos a ver si esto funciona, como lo hemos hecho aquí.
Wikis.
He puesto wikis.
Vale, a ver.
Vale.
Se me quejan unas cuantas cosas, ¿eh?
Se me quejan unas cuantas cosas, pero igual es que soy yo que...
A ver qué he hecho por aquí.
We load.
We load.
Can't be formatted using...
A ver, lo que he notado, una cosa que he notado es esto, ¿vale?
Que aquí ha hecho algo como una nueva forma, una nueva sintaxis,
que se supone que te permite mostrar una estructura de un enum, ¿vale?
Y leerlo de ahí.
Pero a mí esto, a mí esto, al menos no está funcionando.
We load.
Igual es que he hecho algo que no...
Diferente aquí.
We click.
A ver, esto en este caso creo que es lo mismo.
Ta, ta, ta.
Y esto lo he hecho igual.
We click.
Click.
El stroke.
Le clic.
A ver, me voy a copiar todo el código.
A ver si es que igual la he liado con algo.
Pero a mí me parece que no, ¿eh?
Ah, es que además encima, encima, ahí hay cosas que no han creado.
No ves que sigue petando.
Tide the book es no simplemente for web event.
Yo creo que aquí, yo creo que este tipo de transformación que comenta no funciona.
A ver, entiendo a lo mejor que todavía no está terminado.
Pero es que no...
O sea, yo creo que aquí lo que dice es que web event doesn't implement the book the trade.
The book es no simplemente for web event.
O sea, le falta algo para poder mostrar.
La verdad es que eso me estaba extrañando bastante.
Que el hecho de que pudiera mostrar esto tal cual.
No sé si es que ha añadido algo en algún momento ahí para el de book.
No.
Pero es este, básicamente.
We keys, we click, we load, web event, we load.
Lo mismo.
Sí, no, tiene que ver con algo o toca el de playground.
Sí, sí, derive the bug.
¿Cómo que está debajo?
Claro, claro.
Por eso digo que quiero decir, a ver, que tiene solución, tiene solución, ¿vale?
Que me imagino que será esto de aquí.
Lo que quiero decir es que quería ver si es que yo había hecho algo.
O sea, es lo que la persona, esto que hay aquí, como podemos ver, tampoco tiene ese código, ¿vale?
O sea, tampoco tiene esto de, derive, no sé qué, to web event, to manually implement...
Nos dice que podemos hacer esto.
Ya, pero esto, ¿dónde se tiene que poner?
Aquí.
Add, derive, debug to web event.
O sea, entiendo que esto habría que ponerlo aquí.
Y esto, o sea, habría que seguir tirando.
Y esto aquí.
Y esto aquí.
Y creo que ahora sí que estaría.
¿Vale?
Ahora sí que funciona.
Hostia, pero es un poco raro porque, claro, dice, este es el código final, que instancia, no sé qué.
Intente interaccionar con este ejemplo.
Coño.
Es un poco raro.
Vale, que entiendo que habla de esto, pero es lo que decía el error, pero ya decía yo.
Al final, el tema es que para poder tener...
Esto es como ponerle una banderilla, ¿no?
Para decir, oye, quiero debugar esto.
La verdad es que es un poco rollo.
Porque si tienes que poner esto en todos los sitios que quieras debuggar esto, no está mal, ¿no?
No está mal.
Y entonces, ahora sí, nos aparece esta estructura de los synoms.
Es un poco complicado, ¿eh?
O sea, es un poco difícil esto.
Porque entonces, si no quieres debugarlo así, habrá alguna forma.
Entiendo que a lo mejor sí que hay alguna forma de ponerle este flag para indicarle cómo tiene que formatear la salida.
Entiendo que se podrá hacer.
Entiendo que se podrá hacer sin necesidad de hacer esto.
Bueno, pues ya está.
Bueno, pues es eso.
Es fundamental que debes hacer apps de escritorios, drivers y tal.
Continúa la domido, es lo que sigue.
Continúa leyendo.
Tienes que usar el...
Que sí, que siga el tuto.
Pero lo que quiero decir, lo que quiero decir es que es muy raro, es muy raro que lo explique así.
A ver, lo que quiero decir es que este código, yo no lo hubiera puesto aquí.
Lo que hubiera dicho después de esto, en lugar de permitir esto, sería decir, vamos a ver, vale, hasta aquí hemos llegado.
¿Cómo podemos ver este print?
Porque si te dice, try to interact with this example.
Es que, claro, tú llegas a esta línea de intenta interaccionar, tú llegas aquí, te vas aquí al playground y esto no funciona.
Y encima ni siquiera te dice, vas a ver que no funciona.
No te dice esto.
Te dice, tú intenta interaccionar.
Te quedas ahí como, hostia, ¿qué ha pasado?
Y aún así, aquí, tampoco es que te diga este... ¿Ves? Es que está como si ya lo hubiera puesto.
Dice, este statement, no sé qué, no sé cuánto, no sé qué.
Pero dice, joder, pero a ver.
Ah, que solo se pone una vez al inicio.
Visto, vale, vale.
Yo lo había puesto encima de cada uno, pensaba que era como un decorador.
Que había que ponerle.
O sea, que se pone una vez al principio.
O sea, no, según esto, no, me has engañado.
Me has engañado.
Mira, está estimando.
Hay que ponerlo en todos los lados.
Según esto hay que ponerlo en todos los lados.
Mástimo, eh.
Mástimo, Carlos Dami.
Mástimo.
Mástimo.
Bueno, ya hemos hecho el debug.
Vamos a ver el Check Your Knowledge.
Answer the following questions to see what you've learned.
Bueno, hemos aprendido cómo hacer tutoriales.
Bueno, vamos a ver.
Una respuesta de cada pregunta.
Vale, bueno, solo hay una pregunta.
Todas las variantes en Rast son agrupadas juntas con el mismo tipo.
Las funciones que usan cualquier variante de un enum tienen que aceptar todas las variantes.
¿Cómo puedes, how can you work, cómo puedes trabajar con estos requerimientos de las variantes?
Definir un enum separado para cada variante en enum para poder tener la variante data.
Definir un enum que solo tenga una variante.
¿Estás seguro o no?
Definir un enum que usa variantes de todos los tipos.
Hostia, entiendo que esta, ¿no?
Definir un enum separado para cada variante.
Entiendo que es esta.
Definir un enum que usa las variantes de todos que son el mismo tipo.
No, es la primera, ¿vale?
Vamos a verla.
La primera.
Muy bien.
A ver, ¿cuál es el libro de Rast que me estáis diciendo por ahí?
Official book.
Este.
Ah, además es gratis, ¿no?
O sea, encima es gratis aquí.
Qué chulo, ¿no?
Que encima sea totalmente gratis.
Pues me lo leeré porque me parece genial.
Hombre, Oscar, gracias por esos 100 bits.
Trabajar con funciones en Rast.
Vale, pues vamos con las funciones.
Pero es un tuto como...