Módulos

La programación modular es el concepto de agrupar lógicamente funcionalidades relacionadas en

módulos y trabajar con ellos. Este enfoque te permite envolver la funcionalidad relacionada en módulos
y te permite importar la funcionalidad requerida que está disponible en esos módulos. V ofrece el
concepto de programación modular, permitiéndote crear e importar módulos que comprenden código
que es funcional o lógicamente relevante por naturaleza. Para ayudarte a entender cómo trabajar con
módulos, en este capítulo, cubriremos los siguientes temas:
• Introducción a los módulos
• Trabajando con módulos
Para comenzar, aprenderás sobre la sintaxis básica para definir e importar módulos. En las secciones
posteriores, explorarás cómo crear un proyecto simple en V y luego aprenderás cómo crear e importar
módulos definidos en nuestro proyecto simple. A continuación, aprenderás cómo crear múltiples
archivos y trabajar con ellos en un módulo, junto con la comprensión del alcance de acceso.
También aprenderás sobre mejores prácticas, incluyendo los beneficios de la función inicializadora y
las condiciones para definir la función inicializadora para un módulo. Este capítulo también cubre
problemas que surgen en V cuando tenemos importaciones cíclicas al crear módulos. Además de esto,
explorarás los ámbitos de los miembros y la accesibilidad de los miembros, incluyendo constantes,
estructuras y estructuras embebidas entre módulos. Al final de este capítulo, estarás bien versado en los
conceptos de módulos y cómo aprovecharlos al escribir aplicaciones de software en V.

Requisitos técnicos
El código fuente completo para este capítulo está disponible en
[Link]

Introducción a los módulos

Los módulos en V te permiten agrupar lógicamente bloques o piezas de funcionalidad relacionadas. El
concepto de módulos te ofrece la capacidad de estructurar la base de código y hace que el código se vea
bien organizado y fácilmente identificable. Comencemos a aprender sobre el enfoque modular en V
mirando la sintaxis para definir e importar el módulo. También aprenderemos cómo crear un módulo
con funciones públicas y acceder a ellas desde fuera del módulo.

La sintaxis para definir un módulo

V te permite definir un módulo usando la palabra clave module seguida del nombre del módulo. El
siguiente código especifica la sintaxis de cómo definir un módulo:
module MI_MODULO
En la sintaxis anterior, MI_MODULO puede ser cualquier nombre que signifique la funcionalidad que
está presente dentro del módulo. La convención de nomenclatura de módulos es similar a la de las
variables, como se detalla en la sección Convención de nomenclatura de variables del Capítulo 3,
Variables, Constantes y Comentarios de Código.

La sintaxis para importar un módulo

V te permite consumir un módulo usando la palabra clave import, y la sintaxis para importar un
módulo se muestra en el siguiente código:
import MI_MODULO

La sintaxis anterior te muestra cómo consumir un módulo llamado MI_MODULO. Podemos observar
que el nombre del módulo debe especificarse después de la palabra clave import.

Veamos la sintaxis para acceder a los miembros del módulo importado.

La sintaxis para acceder a los miembros del módulo

Una vez que importas cualquier módulo, debe ser consumido. Esto significa que debemos llamar al
menos a uno de los miembros públicos como funciones, estructuras, constantes o enumeraciones
marcadas con la palabra clave pub en el módulo.

La siguiente sintaxis te muestra cómo consumir los miembros públicos como funciones o estructuras de
un módulo importado:
MI_MODULO.MIEMBROS_PUBLICOS_DE_MI_MODULO

Se puede acceder a los miembros públicos del módulo importado especificando el nombre del módulo
importado seguido de un . (punto) y luego especificamos los miembros que están marcados como
públicos usando la palabra clave pub dentro del módulo.

Si el módulo importado no se utiliza en ninguna parte del código, el compilador de V te advertirá con el
mensaje de advertencia: module 'MI_MODULO' is imported but never used cuando
ejecutemos el programa.
Ahora que hemos entendido los conceptos básicos de un módulo, en la siguiente sección, echemos un
vistazo a las cosas a tener en cuenta cuando trabajamos con módulos.

Trabajando con módulos

El enfoque de programación modular ofrece mantenibilidad y reutilización de código. También te
ayuda a añadir abstracciones y te permite exponer solo la funcionalidad necesaria a los consumidores
del módulo. Se recomienda que aprendas cómo trabajar con módulos y examines cómo crear y
organizar eficientemente aplicaciones cuya funcionalidad abarque varios módulos. En esta sección,
aprenderás sobre los diversos principios para definir y trabajar con módulos:
• El nombre del directorio debe coincidir con el nombre del módulo.
 • Los módulos importados deben ser consumidos en el código.
• Múltiples archivos V en el módulo deben definir el mismo módulo.
• Tanto los miembros privados como públicos de un módulo pueden ser accedidos desde
cualquier lugar dentro del módulo.
• Solo los miembros públicos del módulo son accesibles fuera del módulo.
• Las importaciones cíclicas no están permitidas.
• Define funciones init para ejecutar una funcionalidad inicializadora a nivel de módulo por única
vez.
Todo el código V que se muestra más adelante en este capítulo comenzará con un comentario que
indica el nombre del archivo junto con la ruta relativa del archivo concerniente al proyecto en el que
estamos trabajando. Esto está exento para comandos típicos y fragmentos de V que muestran un trozo
de código V:
// archivo: hello/nombre_archivo.v

Por ejemplo, si encuentras los comentarios al principio del bloque de código, como se muestra en el
bloque de código anterior, esto indica que el código pertenece a nombre_archivo.v bajo el
directorio llamado hello.

También ten en cuenta que cuando se menciona ejecutar el proyecto desde el Terminal, es necesario
ejecutar el proyecto con el comando v run . desde el directorio raíz del proyecto.

Vamos a entender cada uno de los principios que se aplican cuando trabajamos con módulos usando
ejemplos.

Creando un proyecto simple en V

Antes de comenzar, crearemos un proyecto demo de V, llamado modulebasics. Luego, obtendremos una
comprensión de todos los principios mencionados anteriormente implementándolos en este proyecto a
través de ejemplos. Los siguientes son los pasos para crear el proyecto demo:
1. Desde el Terminal, navega al directorio de tu elección y ejecuta el siguiente comando:
v new modulebasics

Se te solicitará con entradas para la descripción del proyecto, versión e información de licencia,
de la siguiente manera:
Input your project description: Understanding Modules in V
Input your project version: (0.0.0)
Input your project license: (MIT)
Initialising …
Complete!

2. Proporciona la descripción, versión e información de licencia, o salta esto

presionando la tecla Enter, y verás que el prompt muestra el estado de
creación del proyecto como Complete!.
 3. Ahora, desde el Símbolo del Sistema, establece el directorio actual al nuevo
proyecto que acabamos de crear ejecutando el comando de la siguiente manera:

cd modulebasics

Una vez que hayas hecho esto, tendrás un nuevo proyecto V con tres archivos en un directorio
llamado modulebasics. Los tres archivos son los siguientes:

a) .gitignore
b) modulebasics.v
c) [Link]
El archivo .gitignore es para Git y contendrá la lista de archivos, extensiones de archivo y
directorios que deben ignorarse al enviar nuestro proyecto a controles de fuente basados en Git
como GitHub, GitLab o BitBucket.
El archivo modulebasics.v es el punto de entrada para la aplicación que acabamos de crear.
El comando v new también ha añadido el código boilerplate al archivo modulebasics.v
de la siguiente manera:
// archivo: modulebasics.v
module main
fn main() {
println('Hello World!')
}

Aquí, modulebasics.v es el punto de entrada a nuestro proyecto y se identifica por la

definición del módulo principal presente en el archivo module main. También se identifica
por la presencia de fn main(), que indica la función de punto de entrada principal.

El archivo [Link] tiene información del módulo que expondrá detalles como el nombre,
descripción, versión, licencia y dependencias a los otros proyectos que importen este módulo.
Ahora, procederemos a crear un módulo en nuestro proyecto existente.
4. Ejecutaremos el proyecto modulebasics ejecutando el siguiente comando desde el Terminal:
v run .

El comando anterior muestra la siguiente salida:

Hello World!

Ahora que hemos configurado un proyecto para trabajar con módulos, podemos seguir adelante y crear
un módulo.

Creando un módulo
Crearemos un módulo en nuestro proyecto modulebasics. El primer principio a tener en cuenta al
crear un módulo es que el nombre del directorio debe coincidir con el nombre del módulo. No tener un
nombre similar para el directorio y el módulo conducirá a un error con un mensaje que dice builder
error: bad module definition.

Vamos a crear un módulo llamado mod1 ejecutando el siguiente comando desde el Terminal:
mkdir mod1

El comando anterior crea un directorio llamado mod1, que será el nombre del módulo. Crea un archivo
llamado file1.v en el directorio mod1 con el siguiente código:
// archivo: mod1/file1.v
module mod1

pub fn hello(){
println('Hello from mod1!')
}

En el código anterior, podemos observar que la definición del módulo se identifica por la declaración
module mod1 en file1.v. Esto indica que el nombre del módulo es el mismo que el nombre del
directorio, que es mod1. Además, en el archivo file1.v, hemos creado una función pública llamada
hello. La función hello está marcada como pública usando la palabra clave pub y es accesible
dentro y fuera del módulo. Esto permite que la función hello esté disponible para el código que importa
el módulo mod1.
En esta etapa, la estructura de directorios de nuestro proyecto aparecerá de la siguiente manera:
E:\MODULEBASICS
| .gitignore
| modulebasics.v
| [Link]
|
\---mod1
file1.v

Ahora, procederemos importando este módulo, lo cual se demuestra en la siguiente sección.

Importando un módulo
Como hemos creado con éxito un módulo llamado mod1, seguiremos adelante e importaremos este
módulo en el módulo principal desde el archivo modulebasics.v. Actualiza el código en el archivo
modulebasics.v para importar el módulo mod1, como se muestra aquí:
// archivo: modulebasics.v
module main

import mod1

fn main() {
println('Hello World!')
}
Ten en cuenta que modulebasics.v ahora importa el módulo mod1, que se identifica por la
declaración import mod1. Ahora, ejecutemos el proyecto desde el Terminal proporcionando el
siguiente comando:
v run .

La ejecución del comando anterior mostrará la siguiente salida junto con una advertencia:
.\modulebasics.v:3:8: warning: module 'mod1' is imported but never used
1 | // archivo: modulebasics.v
2 | module main
3 | import mod1
| ~~~~
4 |
5 | fn main() {
Hello World!

Podemos observar que la última línea es la salida del programa que imprime el mensaje Hello
World! de la función principal. El resto de la salida desde el principio es una advertencia que detalla
module mod1 is imported but never used. Así que, en la siguiente sección, echemos un
vistazo a cómo acceder a los miembros de un módulo importado.

Accediendo a miembros de un módulo

Como ya hemos aprendido, el segundo principio dice que los módulos importados deben ser
consumidos en el código, así que sigamos adelante y consumamos los miembros públicos del mod1.

Ya hemos definido una función pública hello en el módulo mod1. La función pública hello de
mod1 puede ser accedida con la ayuda del módulo importado mod1 con la sintaxis [Link]().
Ahora, el código en el archivo modulebasics.v se cambiará de la siguiente manera:
// archivo: modulebasics.v
module main

import mod1

fn main() {
[Link]()
println('Hello World!')
}

El archivo modulebasics.v importa el módulo mod1 y también consume la función pública

hello con la declaración [Link](). Ahora con estos cambios en su lugar, ejecutemos el
proyecto con el comando desde el Terminal de línea de comandos, de la siguiente manera:
v run .

La salida del comando anterior aparecerá como sigue:

Hello from mod1!
Hello World!
La declaración [Link]() se ejecuta y el programa imprime una salida Hello from mod1!
en la consola, que es la funcionalidad encerrada en la función hello del módulo mod1. La salida
también imprime Hello World! en la consola, que es según la secuencia de la ejecución
mencionada en la función main del archivo modulebasics.v.

Trabajando con múltiples archivos en un módulo

Hasta ahora, solo teníamos un solo archivo en el módulo mod1. Ahora entenderemos los detalles de
trabajar con múltiples archivos en un solo módulo.
Si hay múltiples archivos en un módulo, entonces todos los archivos deben definir la misma definición
de módulo. No definir el mismo módulo para todos los archivos dentro de un módulo conducirá a un
error similar a builder error: bad module definition.

Vamos a crear otro archivo, llamado file2.v, en el módulo mod1 con el siguiente código:
// archivo: mod1/file2.v
fn hello2() {
println('Hello 2 from mod1!')
}

En esta etapa, la estructura de directorios de nuestro proyecto aparecerá de la siguiente manera:

E:\MODULEBASICS
| .gitignore
| modulebasics.v
| [Link]
|
\---mod1
file1.v
file2.v

Aquí, el archivo file2.v tiene una función privada llamada hello2. La función hello2 solo
imprime el mensaje en la salida estándar. Con estos cambios en su lugar, ejecutemos el proyecto con el
siguiente comando:
v run .

La salida del comando anterior mostrará un error, de la siguiente manera:

.\modulebasics.v:4:1: builder error: bad module definition: .\modulebasics.v
imports module "mod1" but E:\modulebasics\mod1\file2.v is defined as module 'main'
2 | module main
3 |
4 | import mod1
| ~~~~~~~~~~~
5 |
6 | fn main() {

Esto es porque el código en file2.v no define module mod1. Por defecto, V asume que un módulo
será el módulo principal para los archivos que no tienen una definición de módulo. Ya hemos definido
el módulo principal, que podría identificarse con la declaración module main en
modulebasics.v.

Cuando ejecutamos el proyecto, el compilador de V encuentra el archivo file2.v, que no tiene ninguna
definición de módulo. El compilador lo trata como el módulo principal, y por lo tanto, arrojará un error
con un mensaje que dice builder error: bad module definition: ..v imports
module "mod1" but E:12.v is defined as a module.

Según el tercer principio, múltiples archivos V en el módulo deben definir el mismo módulo, podemos
deshacernos de este error definiendo la definición del módulo en file2.v como module mod1, que
es similar a la de file1.v. Ahora, el archivo file2.v actualizado aparecerá de la siguiente manera:
// archivo: mod1/file2.v
module mod1

fn hello2() {
println('Hello 2 from mod1!')
}

Aquí, file2.v también tiene una declaración de definición de módulo similar de module mod1,
como se identifica en file1.v. Ahora, si ejecutamos el proyecto con el comando v run . en el
Terminal, la salida aparecerá de la siguiente manera:
Hello from mod1!
Hello World!

Podemos observar que la salida está imprimiendo las declaraciones println de las funciones hello y
main. Esto es porque actualmente no hemos comenzado a consumir la nueva función hello2 que
acabamos de definir. Además, nota que la función hello2 no está marcada como pública y solo puede
ser accedida desde dentro del módulo mod1.

En la siguiente sección, examinaremos cómo podemos acceder a la función hello2 desde dentro del
módulo mod1. Exploraremos, en detalle, el ámbito de miembro de los miembros del módulo dentro y
fuera del módulo.

Alcance de miembros en el módulo

El alcance predeterminado para los miembros de un módulo es privado. Estos miembros privados
pueden ser accedidos internamente dentro del módulo. Específicamente, miembros como funciones,
structs, constantes o enumeraciones definidas en el módulo son accesibles en todo el módulo. Solo los
miembros marcados como públicos usando la palabra clave pub son accesibles fuera del módulo.

Hasta ahora, nuestro proyecto modulebasics tiene un módulo llamado mod1 que tiene dos
archivos: file1.v y file2.v. La estructura de árbol del proyecto se ve así:
E:\MODULEBASICS
| .gitignore
| modulebasics.v
| [Link]
|
\---mod1
file1.v
file2.v

Intentemos acceder a la función hello2 desde el módulo principal, de la siguiente manera:

// archivo: modulebasics.v
module main

import mod1

fn main() {
[Link]()
mod1.hello2()
}

Aquí, hello2 no está marcada como pública, y acceder a ella desde el módulo principal genera una
excepción con el error: function mod1.hello2 is private.

Según el cuarto principio de trabajo con módulos, tanto los miembros privados como públicos de un
módulo son accesibles desde cualquier lugar dentro del módulo. Para entender este principio,
actualicemos la función pública hello del módulo mod1 para llamar a hello2, que es una función
privada:
// archivo: mod1/file1.v
module mod1

pub fn hello() {
println('Hello from mod1!')
// hello2 no es pública pero es accesible dentro de mod1
hello2()
}

Según el quinto principio de trabajo con módulos, solo los miembros públicos de un módulo son
accesibles fuera del módulo. Actualicemos el archivo modulebasics.v para que llame a la función
pública hello, de la siguiente manera:
// archivo: modulebasics.v
module main

import mod1

fn main() {
[Link]()
}

Aquí está la salida:

Hello from mod1!
Hello 2 from mod1!
La función hello2, aunque no está marcada como pública, es accesible en todo el módulo mod1. Por
lo tanto, se llama en la función hello, que ya es accesible para el módulo principal ya que ha sido
marcada como pública usando la palabra clave pub.

Implicaciones de importaciones cíclicas

Hay pocas instancias en las que los programadores terminan teniendo dos módulos que utilizan la
funcionalidad del otro. En tales situaciones, existe la posibilidad de que las importaciones de estos
módulos terminen siendo cíclicas por naturaleza. Por ejemplo, digamos que tienes dos módulos, m1 y
m2, en un proyecto modulebasics con el siguiente código:
// archivo: m1/file1.v
module m1

import m2

pub const greet_from_m1 = 'Greetings from m1'

pub fn hello() {
println(m2.greet_from_m2)
}

Aquí, el código anterior pertenece al módulo m1 que tiene una constante greet_from_m1 marcada
con la palabra clave pub. También tiene una función pública hello que imprime la constante del
módulo m2 importado.

Ahora, echemos un vistazo al módulo m2 con el siguiente código:

// archivo: m2/file1.v
module m2

import m1

pub const greet_from_m2 = 'Greetings from m2'

pub fn hello() {
println(m1.greet_from_m1)
}

El código mencionado pertenece al módulo m2, que tiene una constante greet_from_m2 marcada
con la palabra clave pub. También tiene una función pública hello que imprime la constante del
módulo m1 importado. Entonces, el módulo m1 se refiere a m2, y m2 se refiere a m1, lo que introduce
una referencia circular o cíclica. Ahora, si actualizamos nuestro archivo modulebasics.v, se verá
similar a lo siguiente:
// archivo: modulebasics.v
module main
import m1
import m2

fn main() {
[Link]()
[Link]()
}
El archivo modulebasics.v importa los módulos m1 y m2 y llama a la función hello disponible
en cada uno de estos módulos en la función main. Ahora, ejecutemos modulebasics.v con el
comando v run . y veamos cuál será la salida. Según el sexto principio de trabajo con módulos, que
dice que las importaciones cíclicas no están permitidas, observarás que la salida aparece con un detalle
de error, de la siguiente manera:
builder error: error: import cycle detected between the
following modules:
* main -> m1 -> m2 -> m1
* m1 -> m2 -> m1
* m2 -> m1 -> m2

De la salida, podemos ver que el control de ejecución primero ingresa al módulo principal y tiene el
siguiente flujo de control de ejecución:
• m1 -> m2 -> m1: El control de ejecución ingresa a la función hello() del módulo m1.
Luego accede a la constante greet_from_m2 de m2. Después de esto, el control fluye de
vuelta a m1 e imprime la constante.

• m2 -> m1 -> m2: El control de ejecución ingresa a la función hello() del módulo m2.
Luego accede a la constante greet_from_m1 de m1. Después de esto, el control fluye de
vuelta a m2 e imprime la constante.

Estos dos flujos son de naturaleza circular. Los dos módulos m1 y m2 están tratando de importar y
acceder a los miembros del otro, y esto ha llevado a un error con el mensaje builder error:
error: import cycle detected between the following modules.

La función init para un módulo

El último principio de trabajo con módulos te pide que definas funciones init para ejecutar la
funcionalidad de inicialización a nivel de módulo que se ejecuta una sola vez. Los módulos en V te
permiten definir una función llamada init que se ejecuta automáticamente cuando importas el módulo
donde está definida. Las funciones init de un módulo actúan como inicializadores de ciertas
funcionalidades, como establecer conexiones de base de datos o inicializar bibliotecas C o
configuraciones específicas del módulo, si las hay. Para definir la función inicializadora, debes cumplir
con las siguientes condiciones:
• La función init debe definirse solo una vez dentro del módulo.
• La función init no debe marcarse como pública.
• La función init no debe aceptar ningún argumento de entrada.
• La función init no debe tener un tipo de retorno.

Aunque puedes definir una función pública llamada init con al menos un argumento de entrada, no
actúa como una función inicializadora del módulo.
Exploremos la función init() usando un ejemplo. En nuestro proyecto de demostración,
modulebasics, modifiquemos el módulo mod1 para que file1.v tenga el siguiente código:
// archivo: mod1/file1.v
module mod1

pub fn hello() {
println('Hello from mod1!')
}

fn init() {
println('Initializing mod1')
}

Aquí, la nueva función privada init se agrega al archivo file1.v del módulo mod1. En este caso,
simplemente estamos imprimiendo un mensaje que dice Initializing mod1 en la consola. Ahora
actualizaremos el código del archivo modulebasics.v, indicando el siguiente módulo principal:
// archivo: modulebasics.v
module main
import mod1
fn main() {
[Link]()
}

En el módulo principal, estamos llamando a la función hello que está marcada como pública usando
la palabra clave pub. La función privada init está definida en mod1, como aprendimos que esta será
la función inicializadora que se ejecuta antes que cualquier otra función del módulo mod1. Para ver
esto, ejecutaremos el proyecto usando el comando v run .. La salida del código anterior aparecerá
de la siguiente manera:
Initializing mod1
Hello from mod1!

Observa que antes de ejecutar cualquier otra función, la salida imprime el mensaje "Initializing
mod1" de la función init. Solo entonces imprimirá el mensaje Hello from mod1! de la función
hello.

Accediendo a las constantes de un módulo

Acceder a las constantes de un módulo desde otro es un enfoque sencillo. Puedes acceder a las
constantes del módulo siempre que estén marcadas como públicas usando la palabra clave pub.

En nuestro proyecto de ejemplo modulebasics, consideremos el módulo mod1 con file1.v con
el siguiente código:
// archivo: mod1/file1.v
module mod1
pub const greet_msg = 'Greeting from mod1!'

En el código anterior, hemos definido una constante llamada greet_msg en el módulo mod1.
Además, marcamos la constante como pública usando la palabra clave pub. Aprenderemos cómo
acceder a esta constante desde el módulo principal. Cambia el código en el módulo principal para que
se vea como el siguiente:
// archivo: modulebasics.v
module main
import mod1
fn main() {
println(mod1.greet_msg)
}

El código anterior importa el módulo mod1. En la función main, que es el punto de entrada de nuestro
control de ejecución, estamos accediendo a la constante greet_msg del módulo mod1 e
imprimiéndola en la consola:
Greeting from mod1!

La salida anterior muestra el valor asignado a la constante greet_msg del módulo mod1 siendo
impreso desde el módulo principal.

Accediendo a structs y structs embebidos de un módulo

En esta sección, exploraremos en detalle cómo acceder a los campos de struct y campos de structs
embebidos de un módulo mod1 desde el módulo principal. Actualizaremos el proyecto
modulebasics de modo que, en el módulo mod1, tengamos dos structs, NoteTimeInfo y Note,
definidos de la siguiente manera:
// archivo: mod1/file1.v
module mod1
import time

// NoteTimeInfo es un struct para almacenar información de tiempo de Note

pub struct NoteTimeInfo {
pub:
created [Link] = [Link]()
pub mut:
due [Link] = [Link]().add_days(1)
}

// Note es un struct con el struct NoteTimeInfo embebido

// junto con otros campos
pub struct Note {
NoteTimeInfo // Struct embebido
pub:
id int
pub mut:
message string [required]
status bool
}

Ambos structs, NoteTimeInfo y Note, están marcados como públicos usando la palabra clave pub.
Para el struct NoteTimeInfo, el campo created está marcado como público, y due está marcado
como público y mutable usando las palabras clave pub mut. Ambos campos created y due del
struct NoteTimeInfo tienen el valor predeterminado inicializado. De manera similar, para el struct
Note, el campo id está marcado como público y los campos message y status están marcados como
públicos y mutables.
Ahora, actualicemos el módulo principal para acceder a los campos de struct y campos de struct
embebidos de la siguiente manera:
// archivo: modulebasics.v
module main
import mod1
fn main() {
n := [Link] {
id: 1
message: 'Accessing structs of module demo'
}
println('Accessing struct field value Note id: $[Link]')
println('Accessing embedded struct field value NoteTimeInfo: $[Link]')
}

El código anterior muestra que accedimos a los structs Note y NoteTimeInfo del módulo mod1 en
el módulo principal y estamos inicializando el struct Note. Luego, estamos imprimiendo su campo id
y el campo del struct embebido, NoteTimeInfo. El código anterior proporciona la siguiente salida:
Accessing struct field value Note id: 1
Accessing embedded struct field value NoteTimeInfo: [Link]{
created: 2021-05-30 01:45:36
due: 2021-05-31 01:45:36
}

La salida anterior muestra el resultado de acceder al campo id del struct y al campo del struct
embebido NoteTimeInfo del struct Note, que está definido con un especificador de acceso público
pub en el módulo mod1.

Resumen
En este capítulo, comprendimos claramente el concepto de programación modular en V. Aprendimos
cómo crear e importar módulos junto con varios conceptos que nos ayudan a trabajar con ellos.
Aprendimos, a través de ejemplos de código, que tener módulos hace que el código que pertenece al
proyecto parezca más accesible y organizado. También aprendimos sobre las diversas formas de
trabajar con módulos, incluido el acceso a miembros del módulo como structs, funciones y constantes.
Además, cubrimos cómo trabajar con múltiples archivos dentro de un módulo y entendimos el alcance
de los miembros definidos dentro y fuera de un módulo. Después de esto, aprendimos sobre las
funciones inicializadoras y también entendimos las implicaciones de crear importaciones cíclicas.
Finalmente, cubrimos cómo acceder a los structs y structs embebidos de un módulo usando ejemplos de
código.
Habiendo entendido los módulos, en el próximo capítulo, procederemos a explorar la concurrencia en
V.