update stuff

output/include/me/hashmap/hashmap_env.h

@@ -25,16 +25,25 @@
 #include <stdlib.h>
 #include <string.h>
 
+/// @struct A key-value pair for the hashmap
 typedef struct s_kv_env
 {
 	t_str key;
 	t_str val;
 } t_kv_env;
 
+/// @typedef A function that hashes a key
 typedef void (*t_hash_env_fn)(t_hasher *hasher, t_str *key);
+/// @typedef A function that drops a key-value pair
 typedef void (*t_drop_env_fn)(t_kv_env val);
+/// @typedef A function that compares two keys and returns true if they are equal
 typedef bool (*t_eq_env_fn)(t_str *lhs, t_str *rhs);
 
+
+/// @struct A single entry in the hashmap
+/// @var hash_id The hash of the key
+/// @var kv The key-value pair
+/// @var next The next entry in the bucket
 typedef struct s_entry_env
 {
 	t_usize						hash_id;
@@ -42,6 +51,13 @@ typedef struct s_entry_env
 	struct s_entry_env *next;
 } t_entry_env;
 
+/// @struct A hashmap of keys t_str and values t_str
+/// @var buckets The array of buckets
+/// @var num_buckets The number of buckets
+/// @var hasher The hasher function
+/// @var hfunc The hash function
+/// @var cfunc The comparison function
+/// @var drop The drop function
 typedef struct s_hashmap_env
 {
 	t_entry_env **buckets;
@@ -52,31 +68,56 @@ typedef struct s_hashmap_env
 	t_drop_env_fn drop;
 } t_hashmap_env;
 
-t_hashmap_env *new_hashmap_env(t_hash_env_fn hash,
-											   t_eq_env_fn	 cmp,
-											   t_drop_env_fn drop);
-t_hashmap_env *new_hashmap_with_buckets_env(
-	t_hash_env_fn hash, t_eq_env_fn cmp,
-	t_drop_env_fn drop, size_t cap);
+/// @brief Creates a new hashmap with the given hash, comparison, and drop functions
+/// @param hash The hash function
+/// @param cmp The comparison function
+/// @param drop The drop function
+/// @return A new hashmap
+t_hashmap_env *hmap_new_env(t_hash_env_fn hash, t_eq_env_fn	cmp, t_drop_env_fn drop);
 
-void drop_hashmap_env(t_hashmap_env *hmap);
+/// @brief Creates a new hashmap with the given hash, comparison, and drop functions
+/// @param hash The hash function
+/// @param cmp The comparison function
+/// @param drop The drop function
+/// @param cap The number of buckets
+/// @return A new hashmap
+t_hashmap_env *hmap_new_with_buckets_env(t_hash_env_fn hash, t_eq_env_fn cmp, t_drop_env_fn drop, size_t cap);
 
-void insert_hashmap_env(t_hashmap_env *hmap, t_str key,
-								t_str value);
+/// @brief Drops the hashmap and all of its entries
+/// @param hmap The hashmap to drop
+void hmap_free_env(t_hashmap_env *hmap);
 
-t_str *get_hashmap_env(t_hashmap_env *hmap,
-									  t_str			*key);
-void remove_hashmap_env(t_hashmap_env *hmap, t_str *key);
+/// @brief Inserts a key-value pair into the hashmap
+/// @param hmap The hashmap
+/// @param key The key
+/// @param value The value
+void hmap_insert_env(t_hashmap_env *hmap, t_str key, t_str value);
 
-t_entry_env *hashmap_get_entry_env(t_hashmap_env *hmap,
-												   t_usize				  hash,
-												   t_str			 *key,
-												   t_entry_env	**prev);
+/// @brief Gets the value associated with the key
+/// @param hmap The hashmap
+/// @param key The key
+/// @return The value associated with the key, or NULL if the key is not in the hashmap
+t_str *hmap_get_env(t_hashmap_env *hmap, t_str *key);
+/// @brief Removes the key-value pair from the hashmap
+/// @param hmap The hashmap
+/// @param key The key
+void hmap_remove_env(t_hashmap_env *hmap, t_str *key);
 
-t_error hashmap_env_iter(t_hashmap_env *self,
-								 t_error (*func)(t_usize			 idx,
-												 const t_str *key,
-												 t_str *val, void *ctx),
-								 void *ctx);
+/// @brief Get an entry from the hashmap
+/// @param hmap The hashmap
+/// @param hash The hash of the key
+/// @param key The key
+/// @param prev The previous entry in the bucket
+/// @return The entry, or NULL if the key is not in the hashmap
+/// @note this is an internal function
+t_entry_env *hmap_get_entry_env(t_hashmap_env *hmap, t_usize hash, t_str *key, t_entry_env	**prev);
+
+/// @brief Iterates over the hashmap and calls the given function for each key-value pair
+/// @param self The hashmap
+/// @param func The function to call
+/// @param ctx The context to pass to the function
+/// @return An error code
+/// @note The iteration can be stopped by returning an error code from the function
+t_error hmap_env_iter(t_hashmap_env *self, t_error (*func)(t_usize idx, const t_str *key, t_str *val, void *ctx), void *ctx);
 
 #endif

output/include/me/vec/vec_parser_heredoc.h

@@ -16,9 +16,12 @@
 #include "parser/types/types_heredoc.h"
 #include "me/types.h"
 
+/// @brief A function that takes two t_heredoc and compare them
 typedef bool (*t_vec_parser_heredoc_sort_fn)(t_heredoc *, t_heredoc *);
+/// @brief A function that free an t_heredoc
 typedef void (*t_free_parser_heredoc_item)(t_heredoc);
 
+/// @brief A dynamic array of t_heredoc
 typedef struct s_vec_parser_heredoc
 {
 	t_free_parser_heredoc_item free_func;
@@ -27,32 +30,94 @@ typedef struct s_vec_parser_heredoc
 	t_heredoc		   *buffer;
 } t_vec_parser_heredoc;
 
-t_vec_parser_heredoc vec_parser_heredoc_new(t_usize				  capacity,
-									  t_free_parser_heredoc_item free_function);
+/// @brief Create a new vec_parser_heredoc with a given capacity
+/// @param capacity The capacity of the new vec_parser_heredoc (in terms of elements)
+/// @param free_function The function that will be used to free the elements of the vec_parser_heredoc
+t_vec_parser_heredoc vec_parser_heredoc_new(t_usize capacity, t_free_parser_heredoc_item free_function);
+/// @brief Push an element to the last position of the vec_parser_heredoc
+/// @param vec The vec_parser_heredoc to push the element to
+/// @param element The element to push
 t_error vec_parser_heredoc_push(t_vec_parser_heredoc *vec, t_heredoc element);
-t_error vec_parser_heredoc_push_front(t_vec_parser_heredoc *vec,
-								   t_heredoc	  element);
+
+/// @brief Push an element to the first position of the vec_parser_heredoc
+/// @param vec The vec_parser_heredoc to push the element to
+/// @param element The element to push
+/// @note This operation is O(n)
+t_error vec_parser_heredoc_push_front(t_vec_parser_heredoc *vec, t_heredoc	  element);
+
+/// @brief Get the last element from the vec_parser_heredoc, and remove it from the vec_parser_heredoc
+/// @param vec The vec_parser_heredoc to get the element from
+/// @param[out] out The last element of the vec_parser_heredoc
+/// @return true if the operation failed, false otherwise
 t_error vec_parser_heredoc_pop(t_vec_parser_heredoc *vec, t_heredoc *value);
+
+
+/// @brief Get the first element from the vec_parser_heredoc, and remove it from the vec_parser_heredoc
+/// @param vec The vec_parser_heredoc to get the element from
+/// @param[out] out The first element of the vec_parser_heredoc
+/// @return true if the operation failed, false otherwise
+/// @note This operation is O(n)
 t_error vec_parser_heredoc_pop_front(t_vec_parser_heredoc *vec, t_heredoc *value);
+
+/// @brief Free the vector and all its elements
+/// @param vec The vec_parser_heredoc to free
 void	vec_parser_heredoc_free(t_vec_parser_heredoc vec);
-t_error vec_parser_heredoc_reserve(t_vec_parser_heredoc *vec,
-								t_usize			   wanted_capacity);
-t_error vec_parser_heredoc_find(t_vec_parser_heredoc *vec,
-							 bool (*fn)(const t_heredoc *), t_usize *index);
-t_error vec_parser_heredoc_find_starting(t_vec_parser_heredoc *vec,
-									  bool (*fn)(const t_heredoc *),
-									  t_usize starting_index, t_usize *index);
-t_error vec_parser_heredoc_all(t_vec_parser_heredoc *vec,
-							bool (*fn)(const t_heredoc *), bool *result);
-t_error vec_parser_heredoc_any(t_vec_parser_heredoc *vec,
-							bool (*fn)(const t_heredoc *), bool *result);
-void	vec_parser_heredoc_iter(t_vec_parser_heredoc *vec,
-							 void (*fn)(t_usize index, t_heredoc *value,
-										void *state),
-							 void *state);
+
+/// @brief Make the vec_parser_heredoc at least the given capacity
+/// @param vec The vec_parser_heredoc to reserve
+/// @param wanted_capacity The minimum capacity to reserve
+/// @return true if the operation failed, false otherwise
+t_error vec_parser_heredoc_reserve(t_vec_parser_heredoc *vec, t_usize wanted_capacity);
+
+/// @brief Run the function and returns the index of the first element that returns true
+/// @param vec The vec_parser_heredoc to search in
+/// @param fn The function to run on each element
+/// @param[out] index The index of the first element that returns true
+t_error vec_parser_heredoc_find(t_vec_parser_heredoc *vec, bool (*fn)(const t_heredoc *), t_usize *index);
+
+
+/// @brief Run the function and returns the index of the first element that returns true, but starting at index starting_index
+/// @param vec The vec_parser_heredoc to search in
+/// @param fn The function to run on each element
+/// @param starting_index The index to start the search from
+/// @param[out] index The index of the first element that returns true
+t_error vec_parser_heredoc_find_starting(t_vec_parser_heredoc *vec, bool (*fn)(const t_heredoc *), t_usize starting_index, t_usize *index);
+
+/// @brief Run the function on every element of the vec_parser_heredoc and returns if all elements returned true
+/// @param vec The vec_parser_heredoc to search in
+/// @param fn The function to run on each element
+/// @param[out] result The result of the operation
+/// @return true if the operation failed, false otherwise
+/// @note If the vec_parser_heredoc is empty, result will be true
+t_error vec_parser_heredoc_all(t_vec_parser_heredoc *vec, bool (*fn)(const t_heredoc *), bool *result);
+
+/// @brief Run the function on every element of the vec_parser_heredoc and returns if any element returned true
+/// @param vec The vec_parser_heredoc to search in
+/// @param fn The function to run on each element
+/// @param[out] result The result of the operation
+/// @return true if the operation failed, false otherwise
+/// @note If the vec_parser_heredoc is empty, result will be false
+t_error vec_parser_heredoc_any(t_vec_parser_heredoc *vec, bool (*fn)(const t_heredoc *), bool *result);
+
+/// @brief Run the function on every element of the vec_parser_heredoc
+/// @param vec The vec_parser_heredoc to iterate over
+/// @param fn The function to run on each element
+/// @param state The state to pass to the function
+void	vec_parser_heredoc_iter(t_vec_parser_heredoc *vec, void (*fn)(t_usize index, t_heredoc *value, void *state), void *state);
+
+/// @brief Reverse the order of the elements in the vec_parser_heredoc
+/// @param vec The vec_parser_heredoc to reverse
 void	vec_parser_heredoc_reverse(t_vec_parser_heredoc *vec);
-void	vec_parser_heredoc_sort(t_vec_parser_heredoc		  *vec,
-							 t_vec_parser_heredoc_sort_fn is_sorted);
+
+/// @brief Sort the elements of the vec_parser_heredoc
+/// @param vec The vec_parser_heredoc to sort
+/// @param is_sorted The function to use to compare the elements
+void	vec_parser_heredoc_sort(t_vec_parser_heredoc		  *vec, t_vec_parser_heredoc_sort_fn is_sorted);
+
+/// @brief Get a pointer to the last element of the vec_parser_heredoc
+/// @param vec The vec_parser_heredoc to get the element from
+/// @param[out] out A pointer to the last element of the vec_parser_heredoc
+/// @return true if the operation failed, false otherwise
 t_error vec_parser_heredoc_back(t_vec_parser_heredoc *vec, t_heredoc **out);
 
 #endif

output/include/me/vec/vec_parser_range.h

@@ -16,9 +16,12 @@
 #include "parser/types/types_parser_range.h"
 #include "me/types.h"
 
+/// @brief A function that takes two t_parser_range and compare them
 typedef bool (*t_vec_parser_range_sort_fn)(t_parser_range *, t_parser_range *);
+/// @brief A function that free an t_parser_range
 typedef void (*t_free_parser_range_item)(t_parser_range);
 
+/// @brief A dynamic array of t_parser_range
 typedef struct s_vec_parser_range
 {
 	t_free_parser_range_item free_func;
@@ -27,32 +30,94 @@ typedef struct s_vec_parser_range
 	t_parser_range		   *buffer;
 } t_vec_parser_range;
 
-t_vec_parser_range vec_parser_range_new(t_usize				  capacity,
-									  t_free_parser_range_item free_function);
+/// @brief Create a new vec_parser_range with a given capacity
+/// @param capacity The capacity of the new vec_parser_range (in terms of elements)
+/// @param free_function The function that will be used to free the elements of the vec_parser_range
+t_vec_parser_range vec_parser_range_new(t_usize capacity, t_free_parser_range_item free_function);
+/// @brief Push an element to the last position of the vec_parser_range
+/// @param vec The vec_parser_range to push the element to
+/// @param element The element to push
 t_error vec_parser_range_push(t_vec_parser_range *vec, t_parser_range element);
-t_error vec_parser_range_push_front(t_vec_parser_range *vec,
-								   t_parser_range	  element);
+
+/// @brief Push an element to the first position of the vec_parser_range
+/// @param vec The vec_parser_range to push the element to
+/// @param element The element to push
+/// @note This operation is O(n)
+t_error vec_parser_range_push_front(t_vec_parser_range *vec, t_parser_range	  element);
+
+/// @brief Get the last element from the vec_parser_range, and remove it from the vec_parser_range
+/// @param vec The vec_parser_range to get the element from
+/// @param[out] out The last element of the vec_parser_range
+/// @return true if the operation failed, false otherwise
 t_error vec_parser_range_pop(t_vec_parser_range *vec, t_parser_range *value);
+
+
+/// @brief Get the first element from the vec_parser_range, and remove it from the vec_parser_range
+/// @param vec The vec_parser_range to get the element from
+/// @param[out] out The first element of the vec_parser_range
+/// @return true if the operation failed, false otherwise
+/// @note This operation is O(n)
 t_error vec_parser_range_pop_front(t_vec_parser_range *vec, t_parser_range *value);
+
+/// @brief Free the vector and all its elements
+/// @param vec The vec_parser_range to free
 void	vec_parser_range_free(t_vec_parser_range vec);
-t_error vec_parser_range_reserve(t_vec_parser_range *vec,
-								t_usize			   wanted_capacity);
-t_error vec_parser_range_find(t_vec_parser_range *vec,
-							 bool (*fn)(const t_parser_range *), t_usize *index);
-t_error vec_parser_range_find_starting(t_vec_parser_range *vec,
-									  bool (*fn)(const t_parser_range *),
-									  t_usize starting_index, t_usize *index);
-t_error vec_parser_range_all(t_vec_parser_range *vec,
-							bool (*fn)(const t_parser_range *), bool *result);
-t_error vec_parser_range_any(t_vec_parser_range *vec,
-							bool (*fn)(const t_parser_range *), bool *result);
-void	vec_parser_range_iter(t_vec_parser_range *vec,
-							 void (*fn)(t_usize index, t_parser_range *value,
-										void *state),
-							 void *state);
+
+/// @brief Make the vec_parser_range at least the given capacity
+/// @param vec The vec_parser_range to reserve
+/// @param wanted_capacity The minimum capacity to reserve
+/// @return true if the operation failed, false otherwise
+t_error vec_parser_range_reserve(t_vec_parser_range *vec, t_usize wanted_capacity);
+
+/// @brief Run the function and returns the index of the first element that returns true
+/// @param vec The vec_parser_range to search in
+/// @param fn The function to run on each element
+/// @param[out] index The index of the first element that returns true
+t_error vec_parser_range_find(t_vec_parser_range *vec, bool (*fn)(const t_parser_range *), t_usize *index);
+
+
+/// @brief Run the function and returns the index of the first element that returns true, but starting at index starting_index
+/// @param vec The vec_parser_range to search in
+/// @param fn The function to run on each element
+/// @param starting_index The index to start the search from
+/// @param[out] index The index of the first element that returns true
+t_error vec_parser_range_find_starting(t_vec_parser_range *vec, bool (*fn)(const t_parser_range *), t_usize starting_index, t_usize *index);
+
+/// @brief Run the function on every element of the vec_parser_range and returns if all elements returned true
+/// @param vec The vec_parser_range to search in
+/// @param fn The function to run on each element
+/// @param[out] result The result of the operation
+/// @return true if the operation failed, false otherwise
+/// @note If the vec_parser_range is empty, result will be true
+t_error vec_parser_range_all(t_vec_parser_range *vec, bool (*fn)(const t_parser_range *), bool *result);
+
+/// @brief Run the function on every element of the vec_parser_range and returns if any element returned true
+/// @param vec The vec_parser_range to search in
+/// @param fn The function to run on each element
+/// @param[out] result The result of the operation
+/// @return true if the operation failed, false otherwise
+/// @note If the vec_parser_range is empty, result will be false
+t_error vec_parser_range_any(t_vec_parser_range *vec, bool (*fn)(const t_parser_range *), bool *result);
+
+/// @brief Run the function on every element of the vec_parser_range
+/// @param vec The vec_parser_range to iterate over
+/// @param fn The function to run on each element
+/// @param state The state to pass to the function
+void	vec_parser_range_iter(t_vec_parser_range *vec, void (*fn)(t_usize index, t_parser_range *value, void *state), void *state);
+
+/// @brief Reverse the order of the elements in the vec_parser_range
+/// @param vec The vec_parser_range to reverse
 void	vec_parser_range_reverse(t_vec_parser_range *vec);
-void	vec_parser_range_sort(t_vec_parser_range		  *vec,
-							 t_vec_parser_range_sort_fn is_sorted);
+
+/// @brief Sort the elements of the vec_parser_range
+/// @param vec The vec_parser_range to sort
+/// @param is_sorted The function to use to compare the elements
+void	vec_parser_range_sort(t_vec_parser_range		  *vec, t_vec_parser_range_sort_fn is_sorted);
+
+/// @brief Get a pointer to the last element of the vec_parser_range
+/// @param vec The vec_parser_range to get the element from
+/// @param[out] out A pointer to the last element of the vec_parser_range
+/// @return true if the operation failed, false otherwise
 t_error vec_parser_range_back(t_vec_parser_range *vec, t_parser_range **out);
 
 #endif

output/include/me/vec/vec_reduce_action.h

@@ -16,9 +16,12 @@
 #include "parser/types/types_reduce_action.h"
 #include "me/types.h"
 
+/// @brief A function that takes two t_reduce_action and compare them
 typedef bool (*t_vec_reduce_action_sort_fn)(t_reduce_action *, t_reduce_action *);
+/// @brief A function that free an t_reduce_action
 typedef void (*t_free_reduce_action_item)(t_reduce_action);
 
+/// @brief A dynamic array of t_reduce_action
 typedef struct s_vec_reduce_action
 {
 	t_free_reduce_action_item free_func;
@@ -27,32 +30,94 @@ typedef struct s_vec_reduce_action
 	t_reduce_action		   *buffer;
 } t_vec_reduce_action;
 
-t_vec_reduce_action vec_reduce_action_new(t_usize				  capacity,
-									  t_free_reduce_action_item free_function);
+/// @brief Create a new vec_reduce_action with a given capacity
+/// @param capacity The capacity of the new vec_reduce_action (in terms of elements)
+/// @param free_function The function that will be used to free the elements of the vec_reduce_action
+t_vec_reduce_action vec_reduce_action_new(t_usize capacity, t_free_reduce_action_item free_function);
+/// @brief Push an element to the last position of the vec_reduce_action
+/// @param vec The vec_reduce_action to push the element to
+/// @param element The element to push
 t_error vec_reduce_action_push(t_vec_reduce_action *vec, t_reduce_action element);
-t_error vec_reduce_action_push_front(t_vec_reduce_action *vec,
-								   t_reduce_action	  element);
+
+/// @brief Push an element to the first position of the vec_reduce_action
+/// @param vec The vec_reduce_action to push the element to
+/// @param element The element to push
+/// @note This operation is O(n)
+t_error vec_reduce_action_push_front(t_vec_reduce_action *vec, t_reduce_action	  element);
+
+/// @brief Get the last element from the vec_reduce_action, and remove it from the vec_reduce_action
+/// @param vec The vec_reduce_action to get the element from
+/// @param[out] out The last element of the vec_reduce_action
+/// @return true if the operation failed, false otherwise
 t_error vec_reduce_action_pop(t_vec_reduce_action *vec, t_reduce_action *value);
+
+
+/// @brief Get the first element from the vec_reduce_action, and remove it from the vec_reduce_action
+/// @param vec The vec_reduce_action to get the element from
+/// @param[out] out The first element of the vec_reduce_action
+/// @return true if the operation failed, false otherwise
+/// @note This operation is O(n)
 t_error vec_reduce_action_pop_front(t_vec_reduce_action *vec, t_reduce_action *value);
+
+/// @brief Free the vector and all its elements
+/// @param vec The vec_reduce_action to free
 void	vec_reduce_action_free(t_vec_reduce_action vec);
-t_error vec_reduce_action_reserve(t_vec_reduce_action *vec,
-								t_usize			   wanted_capacity);
-t_error vec_reduce_action_find(t_vec_reduce_action *vec,
-							 bool (*fn)(const t_reduce_action *), t_usize *index);
-t_error vec_reduce_action_find_starting(t_vec_reduce_action *vec,
-									  bool (*fn)(const t_reduce_action *),
-									  t_usize starting_index, t_usize *index);
-t_error vec_reduce_action_all(t_vec_reduce_action *vec,
-							bool (*fn)(const t_reduce_action *), bool *result);
-t_error vec_reduce_action_any(t_vec_reduce_action *vec,
-							bool (*fn)(const t_reduce_action *), bool *result);
-void	vec_reduce_action_iter(t_vec_reduce_action *vec,
-							 void (*fn)(t_usize index, t_reduce_action *value,
-										void *state),
-							 void *state);
+
+/// @brief Make the vec_reduce_action at least the given capacity
+/// @param vec The vec_reduce_action to reserve
+/// @param wanted_capacity The minimum capacity to reserve
+/// @return true if the operation failed, false otherwise
+t_error vec_reduce_action_reserve(t_vec_reduce_action *vec, t_usize wanted_capacity);
+
+/// @brief Run the function and returns the index of the first element that returns true
+/// @param vec The vec_reduce_action to search in
+/// @param fn The function to run on each element
+/// @param[out] index The index of the first element that returns true
+t_error vec_reduce_action_find(t_vec_reduce_action *vec, bool (*fn)(const t_reduce_action *), t_usize *index);
+
+
+/// @brief Run the function and returns the index of the first element that returns true, but starting at index starting_index
+/// @param vec The vec_reduce_action to search in
+/// @param fn The function to run on each element
+/// @param starting_index The index to start the search from
+/// @param[out] index The index of the first element that returns true
+t_error vec_reduce_action_find_starting(t_vec_reduce_action *vec, bool (*fn)(const t_reduce_action *), t_usize starting_index, t_usize *index);
+
+/// @brief Run the function on every element of the vec_reduce_action and returns if all elements returned true
+/// @param vec The vec_reduce_action to search in
+/// @param fn The function to run on each element
+/// @param[out] result The result of the operation
+/// @return true if the operation failed, false otherwise
+/// @note If the vec_reduce_action is empty, result will be true
+t_error vec_reduce_action_all(t_vec_reduce_action *vec, bool (*fn)(const t_reduce_action *), bool *result);
+
+/// @brief Run the function on every element of the vec_reduce_action and returns if any element returned true
+/// @param vec The vec_reduce_action to search in
+/// @param fn The function to run on each element
+/// @param[out] result The result of the operation
+/// @return true if the operation failed, false otherwise
+/// @note If the vec_reduce_action is empty, result will be false
+t_error vec_reduce_action_any(t_vec_reduce_action *vec, bool (*fn)(const t_reduce_action *), bool *result);
+
+/// @brief Run the function on every element of the vec_reduce_action
+/// @param vec The vec_reduce_action to iterate over
+/// @param fn The function to run on each element
+/// @param state The state to pass to the function
+void	vec_reduce_action_iter(t_vec_reduce_action *vec, void (*fn)(t_usize index, t_reduce_action *value, void *state), void *state);
+
+/// @brief Reverse the order of the elements in the vec_reduce_action
+/// @param vec The vec_reduce_action to reverse
 void	vec_reduce_action_reverse(t_vec_reduce_action *vec);
-void	vec_reduce_action_sort(t_vec_reduce_action		  *vec,
-							 t_vec_reduce_action_sort_fn is_sorted);
+
+/// @brief Sort the elements of the vec_reduce_action
+/// @param vec The vec_reduce_action to sort
+/// @param is_sorted The function to use to compare the elements
+void	vec_reduce_action_sort(t_vec_reduce_action		  *vec, t_vec_reduce_action_sort_fn is_sorted);
+
+/// @brief Get a pointer to the last element of the vec_reduce_action
+/// @param vec The vec_reduce_action to get the element from
+/// @param[out] out A pointer to the last element of the vec_reduce_action
+/// @return true if the operation failed, false otherwise
 t_error vec_reduce_action_back(t_vec_reduce_action *vec, t_reduce_action **out);
 
 #endif

output/include/me/vec/vec_str.h

@@ -16,9 +16,12 @@
 
 #include "me/types.h"
 
+/// @brief A function that takes two t_str and compare them
 typedef bool (*t_vec_str_sort_fn)(t_str *, t_str *);
+/// @brief A function that free an t_str
 typedef void (*t_free_str_item)(t_str);
 
+/// @brief A dynamic array of t_str
 typedef struct s_vec_str
 {
 	t_free_str_item free_func;
@@ -27,32 +30,94 @@ typedef struct s_vec_str
 	t_str		   *buffer;
 } t_vec_str;
 
-t_vec_str vec_str_new(t_usize				  capacity,
-									  t_free_str_item free_function);
+/// @brief Create a new vec_str with a given capacity
+/// @param capacity The capacity of the new vec_str (in terms of elements)
+/// @param free_function The function that will be used to free the elements of the vec_str
+t_vec_str vec_str_new(t_usize capacity, t_free_str_item free_function);
+/// @brief Push an element to the last position of the vec_str
+/// @param vec The vec_str to push the element to
+/// @param element The element to push
 t_error vec_str_push(t_vec_str *vec, t_str element);
-t_error vec_str_push_front(t_vec_str *vec,
-								   t_str	  element);
+
+/// @brief Push an element to the first position of the vec_str
+/// @param vec The vec_str to push the element to
+/// @param element The element to push
+/// @note This operation is O(n)
+t_error vec_str_push_front(t_vec_str *vec, t_str	  element);
+
+/// @brief Get the last element from the vec_str, and remove it from the vec_str
+/// @param vec The vec_str to get the element from
+/// @param[out] out The last element of the vec_str
+/// @return true if the operation failed, false otherwise
 t_error vec_str_pop(t_vec_str *vec, t_str *value);
+
+
+/// @brief Get the first element from the vec_str, and remove it from the vec_str
+/// @param vec The vec_str to get the element from
+/// @param[out] out The first element of the vec_str
+/// @return true if the operation failed, false otherwise
+/// @note This operation is O(n)
 t_error vec_str_pop_front(t_vec_str *vec, t_str *value);
+
+/// @brief Free the vector and all its elements
+/// @param vec The vec_str to free
 void	vec_str_free(t_vec_str vec);
-t_error vec_str_reserve(t_vec_str *vec,
-								t_usize			   wanted_capacity);
-t_error vec_str_find(t_vec_str *vec,
-							 bool (*fn)(const t_str *), t_usize *index);
-t_error vec_str_find_starting(t_vec_str *vec,
-									  bool (*fn)(const t_str *),
-									  t_usize starting_index, t_usize *index);
-t_error vec_str_all(t_vec_str *vec,
-							bool (*fn)(const t_str *), bool *result);
-t_error vec_str_any(t_vec_str *vec,
-							bool (*fn)(const t_str *), bool *result);
-void	vec_str_iter(t_vec_str *vec,
-							 void (*fn)(t_usize index, t_str *value,
-										void *state),
-							 void *state);
+
+/// @brief Make the vec_str at least the given capacity
+/// @param vec The vec_str to reserve
+/// @param wanted_capacity The minimum capacity to reserve
+/// @return true if the operation failed, false otherwise
+t_error vec_str_reserve(t_vec_str *vec, t_usize wanted_capacity);
+
+/// @brief Run the function and returns the index of the first element that returns true
+/// @param vec The vec_str to search in
+/// @param fn The function to run on each element
+/// @param[out] index The index of the first element that returns true
+t_error vec_str_find(t_vec_str *vec, bool (*fn)(const t_str *), t_usize *index);
+
+
+/// @brief Run the function and returns the index of the first element that returns true, but starting at index starting_index
+/// @param vec The vec_str to search in
+/// @param fn The function to run on each element
+/// @param starting_index The index to start the search from
+/// @param[out] index The index of the first element that returns true
+t_error vec_str_find_starting(t_vec_str *vec, bool (*fn)(const t_str *), t_usize starting_index, t_usize *index);
+
+/// @brief Run the function on every element of the vec_str and returns if all elements returned true
+/// @param vec The vec_str to search in
+/// @param fn The function to run on each element
+/// @param[out] result The result of the operation
+/// @return true if the operation failed, false otherwise
+/// @note If the vec_str is empty, result will be true
+t_error vec_str_all(t_vec_str *vec, bool (*fn)(const t_str *), bool *result);
+
+/// @brief Run the function on every element of the vec_str and returns if any element returned true
+/// @param vec The vec_str to search in
+/// @param fn The function to run on each element
+/// @param[out] result The result of the operation
+/// @return true if the operation failed, false otherwise
+/// @note If the vec_str is empty, result will be false
+t_error vec_str_any(t_vec_str *vec, bool (*fn)(const t_str *), bool *result);
+
+/// @brief Run the function on every element of the vec_str
+/// @param vec The vec_str to iterate over
+/// @param fn The function to run on each element
+/// @param state The state to pass to the function
+void	vec_str_iter(t_vec_str *vec, void (*fn)(t_usize index, t_str *value, void *state), void *state);
+
+/// @brief Reverse the order of the elements in the vec_str
+/// @param vec The vec_str to reverse
 void	vec_str_reverse(t_vec_str *vec);
-void	vec_str_sort(t_vec_str		  *vec,
-							 t_vec_str_sort_fn is_sorted);
+
+/// @brief Sort the elements of the vec_str
+/// @param vec The vec_str to sort
+/// @param is_sorted The function to use to compare the elements
+void	vec_str_sort(t_vec_str		  *vec, t_vec_str_sort_fn is_sorted);
+
+/// @brief Get a pointer to the last element of the vec_str
+/// @param vec The vec_str to get the element from
+/// @param[out] out A pointer to the last element of the vec_str
+/// @return true if the operation failed, false otherwise
 t_error vec_str_back(t_vec_str *vec, t_str **out);
 
 #endif

output/src/hashmap/env/env.c

@@ -14,19 +14,19 @@
 #include "me/hash/sip.h"
 #include "me/hashmap/hashmap_env.h"
 #include "me/mem/mem.h"
-#include "me/mem/mem_copy.h"
+#include "me/mem/mem.h"
 #include "me/types.h"
 #include <stdlib.h>
 
-t_hashmap_env *new_hashmap_env(t_hash_env_fn hfunc,
+t_hashmap_env *hmap_new_env(t_hash_env_fn hfunc,
 											   t_eq_env_fn	 cfunc,
 											   t_drop_env_fn drop)
 {
-	return (new_hashmap_with_buckets_env(hfunc, cfunc, drop,
+	return (hmap_new_with_buckets_env(hfunc, cfunc, drop,
 												 DEFAULT_BUCKETS));
 }
 
-t_hashmap_env *new_hashmap_with_buckets_env(
+t_hashmap_env *hmap_new_with_buckets_env(
 	t_hash_env_fn hfunc, t_eq_env_fn cfunc,
 	t_drop_env_fn drop, t_usize buckets)
 {
@@ -46,7 +46,7 @@ t_hashmap_env *new_hashmap_with_buckets_env(
 	return (hmap);
 }
 
-void drop_hashmap_env(t_hashmap_env *hmap)
+void hmap_free_env(t_hashmap_env *hmap)
 {
 	t_usize index;
 
@@ -65,7 +65,7 @@ void drop_hashmap_env(t_hashmap_env *hmap)
 	mem_free(hmap);
 }
 
-t_entry_env *hashmap_get_entry_env(t_hashmap_env *hmap,
+t_entry_env *hmap_get_entry_env(t_hashmap_env *hmap,
 												   t_usize		 hashed_key,
 												   t_str *key,
 												   t_entry_env **prev)
@@ -88,7 +88,7 @@ t_entry_env *hashmap_get_entry_env(t_hashmap_env *hmap,
 	return (NULL);
 }
 
-void insert_hashmap_env(t_hashmap_env *hmap, t_str key,
+void hmap_insert_env(t_hashmap_env *hmap, t_str key,
 								t_str value)
 {
 	t_usize				 hashed_key;
@@ -98,7 +98,7 @@ void insert_hashmap_env(t_hashmap_env *hmap, t_str key,
 	hmap->hfunc(&hmap->hasher, &key);
 	hashed_key = hasher_reset_and_finish(&hmap->hasher);
 	prev = NULL;
-	entry = hashmap_get_entry_env(hmap, hashed_key, &key, &prev);
+	entry = hmap_get_entry_env(hmap, hashed_key, &key, &prev);
 	if (entry == NULL)
 	{
 		entry = mem_alloc(sizeof(t_entry_env));

output/src/hashmap/env/env_iter.c

@@ -12,7 +12,7 @@
 
 #include "me/hashmap/hashmap_env.h"
 
-t_error hashmap_env_iter(t_hashmap_env *self,
+t_error hmap_env_iter(t_hashmap_env *self,
 								 t_error (*func)(t_usize			 idx,
 												 const t_str *key,
 												 t_str *val, void *ctx),

output/src/hashmap/env/env_utils.c

@@ -13,11 +13,11 @@
 #include "me/hash/sip.h"
 #include "me/hashmap/hashmap_env.h"
 #include "me/mem/mem.h"
-#include "me/mem/mem_copy.h"
+#include "me/mem/mem.h"
 #include "me/types.h"
 #include <stdlib.h>
 
-t_str *get_hashmap_env(t_hashmap_env *hmap,
+t_str *hmap_get_env(t_hashmap_env *hmap,
 									  t_str			*key)
 {
 	t_usize				 hashed_key;
@@ -26,13 +26,13 @@ t_str *get_hashmap_env(t_hashmap_env *hmap,
 
 	hmap->hfunc(&hmap->hasher, key);
 	hashed_key = hasher_reset_and_finish(&hmap->hasher);
-	entry = hashmap_get_entry_env(hmap, hashed_key, key, &prev);
+	entry = hmap_get_entry_env(hmap, hashed_key, key, &prev);
 	if (entry == NULL)
 		return (NULL);
 	return (&entry->kv.val);
 }
 
-void remove_hashmap_env(t_hashmap_env *hmap, t_str *key)
+void hmap_remove_env(t_hashmap_env *hmap, t_str *key)
 {
 	t_usize				 hashed_key;
 	t_entry_env *prev;
@@ -42,7 +42,7 @@ void remove_hashmap_env(t_hashmap_env *hmap, t_str *key)
 	hashed_key = hasher_reset_and_finish(&hmap->hasher);
 	hmap->hasher = hasher_sip13_new();
 	prev = NULL;
-	entry = hashmap_get_entry_env(hmap, hashed_key, key, &prev);
+	entry = hmap_get_entry_env(hmap, hashed_key, key, &prev);
 	if (entry == NULL)
 		return;
 	if (prev == NULL)

output/src/vec/parser_heredoc/parser_heredoc.c

@@ -10,9 +10,9 @@
 /*                                                                            */
 /* ************************************************************************** */
 
-#include "me/mem/mem_alloc_array.h"
-#include "me/mem/mem_copy.h"
-#include "me/mem/mem_set_zero.h"
+#include "me/mem/mem.h"
+#include "me/mem/mem.h"
+#include "me/mem/mem.h"
 #include "me/types.h"
 #include "me/mem/mem.h"
 #include "me/vec/vec_parser_heredoc.h"

output/src/vec/parser_heredoc/parser_heredoc_functions2.c

@@ -10,9 +10,9 @@
 /*                                                                            */
 /* ************************************************************************** */
 
-#include "me/mem/mem_alloc_array.h"
-#include "me/mem/mem_copy.h"
-#include "me/mem/mem_set_zero.h"
+#include "me/mem/mem.h"
+#include "me/mem/mem.h"
+#include "me/mem/mem.h"
 #include "me/types.h"
 #include "me/vec/vec_parser_heredoc.h"
 #include <stdlib.h>

output/src/vec/parser_heredoc/parser_heredoc_functions3.c

@@ -10,9 +10,9 @@
 /*                                                                            */
 /* ************************************************************************** */
 
-#include "me/mem/mem_alloc_array.h"
-#include "me/mem/mem_copy.h"
-#include "me/mem/mem_set_zero.h"
+#include "me/mem/mem.h"
+#include "me/mem/mem.h"
+#include "me/mem/mem.h"
 #include "me/types.h"
 #include "me/vec/vec_parser_heredoc.h"
 #include <stdlib.h>

output/src/vec/parser_range/parser_range.c

@@ -10,9 +10,9 @@
 /*                                                                            */
 /* ************************************************************************** */
 
-#include "me/mem/mem_alloc_array.h"
-#include "me/mem/mem_copy.h"
-#include "me/mem/mem_set_zero.h"
+#include "me/mem/mem.h"
+#include "me/mem/mem.h"
+#include "me/mem/mem.h"
 #include "me/types.h"
 #include "me/mem/mem.h"
 #include "me/vec/vec_parser_range.h"

output/src/vec/parser_range/parser_range_functions2.c

@@ -10,9 +10,9 @@
 /*                                                                            */
 /* ************************************************************************** */
 
-#include "me/mem/mem_alloc_array.h"
-#include "me/mem/mem_copy.h"
-#include "me/mem/mem_set_zero.h"
+#include "me/mem/mem.h"
+#include "me/mem/mem.h"
+#include "me/mem/mem.h"
 #include "me/types.h"
 #include "me/vec/vec_parser_range.h"
 #include <stdlib.h>

output/src/vec/parser_range/parser_range_functions3.c

@@ -10,9 +10,9 @@
 /*                                                                            */
 /* ************************************************************************** */
 
-#include "me/mem/mem_alloc_array.h"
-#include "me/mem/mem_copy.h"
-#include "me/mem/mem_set_zero.h"
+#include "me/mem/mem.h"
+#include "me/mem/mem.h"
+#include "me/mem/mem.h"
 #include "me/types.h"
 #include "me/vec/vec_parser_range.h"
 #include <stdlib.h>

output/src/vec/reduce_action/reduce_action.c

@@ -10,9 +10,9 @@
 /*                                                                            */
 /* ************************************************************************** */
 
-#include "me/mem/mem_alloc_array.h"
-#include "me/mem/mem_copy.h"
-#include "me/mem/mem_set_zero.h"
+#include "me/mem/mem.h"
+#include "me/mem/mem.h"
+#include "me/mem/mem.h"
 #include "me/types.h"
 #include "me/mem/mem.h"
 #include "me/vec/vec_reduce_action.h"

output/src/vec/reduce_action/reduce_action_functions2.c

@@ -10,9 +10,9 @@
 /*                                                                            */
 /* ************************************************************************** */
 
-#include "me/mem/mem_alloc_array.h"
-#include "me/mem/mem_copy.h"
-#include "me/mem/mem_set_zero.h"
+#include "me/mem/mem.h"
+#include "me/mem/mem.h"
+#include "me/mem/mem.h"
 #include "me/types.h"
 #include "me/vec/vec_reduce_action.h"
 #include <stdlib.h>

output/src/vec/reduce_action/reduce_action_functions3.c

@@ -10,9 +10,9 @@
 /*                                                                            */
 /* ************************************************************************** */
 
-#include "me/mem/mem_alloc_array.h"
-#include "me/mem/mem_copy.h"
-#include "me/mem/mem_set_zero.h"
+#include "me/mem/mem.h"
+#include "me/mem/mem.h"
+#include "me/mem/mem.h"
 #include "me/types.h"
 #include "me/vec/vec_reduce_action.h"
 #include <stdlib.h>

output/src/vec/str/str.c

@@ -10,9 +10,9 @@
 /*                                                                            */
 /* ************************************************************************** */
 
-#include "me/mem/mem_alloc_array.h"
-#include "me/mem/mem_copy.h"
-#include "me/mem/mem_set_zero.h"
+#include "me/mem/mem.h"
+#include "me/mem/mem.h"
+#include "me/mem/mem.h"
 #include "me/types.h"
 #include "me/mem/mem.h"
 #include "me/vec/vec_str.h"

output/src/vec/str/str_functions2.c

@@ -10,9 +10,9 @@
 /*                                                                            */
 /* ************************************************************************** */
 
-#include "me/mem/mem_alloc_array.h"
-#include "me/mem/mem_copy.h"
-#include "me/mem/mem_set_zero.h"
+#include "me/mem/mem.h"
+#include "me/mem/mem.h"
+#include "me/mem/mem.h"
 #include "me/types.h"
 #include "me/vec/vec_str.h"
 #include <stdlib.h>

output/src/vec/str/str_functions3.c

@@ -10,9 +10,9 @@
 /*                                                                            */
 /* ************************************************************************** */
 
-#include "me/mem/mem_alloc_array.h"
-#include "me/mem/mem_copy.h"
-#include "me/mem/mem_set_zero.h"
+#include "me/mem/mem.h"
+#include "me/mem/mem.h"
+#include "me/mem/mem.h"
 #include "me/types.h"
 #include "me/vec/vec_str.h"
 #include <stdlib.h>