vlib/v/checker/tests/check_err_msg_with_generics.vv:15:10: error: cannot cast struct `datatypes.BSTree[Result[[]Token, Err[string]]]` to `int`
   13 | fn test_err_msg() {
   14 |     typ := datatypes.BSTree[Result[[]Token, Err[string]]]{}
   15 |     println(int(typ))
      |             ~~~~~~~~
   16 | }
vlib/datatypes/bstree.v:69:17: error: unknown type `Token`.
Did you mean `Ok[[]Token]`?
   67 | // insert give the possibility to insert an element in the BST.
   68 | pub fn (mut bst BSTree[T]) insert(value T) bool {
   69 |     if bst.is_empty() {
      |                    ^
   70 |         bst.root = new_root_node(value)
   71 |         return true
vlib/datatypes/bstree.v:73:26: error: unknown type `Token`.
Did you mean `Ok[[]Token]`?
   71 |         return true
   72 |     }
   73 |     return bst.insert_helper(mut bst.root, value)
      |                             ^
   74 | }
   75 |
vlib/datatypes/bstree.v:78:16: error: cannot use operator `<` with `Result[[]Token, Err[string]]`
   76 | // insert_helper walks the tree and inserts the given node.
   77 | fn (mut bst BSTree[T]) insert_helper(mut node BSTreeNode[T], value T) bool {
   78 |     if node.value < value {
      |                   ^
   79 |         if unsafe { node.right != 0 } && node.right.is_init {
   80 |             return bst.insert_helper(mut node.right, value)
vlib/datatypes/bstree.v:80:28: error: unknown type `Token`.
Did you mean `Ok[[]Token]`?
   78 |     if node.value < value {
   79 |         if unsafe { node.right != 0 } && node.right.is_init {
   80 |             return bst.insert_helper(mut node.right, value)
      |                                     ^
   81 |         }
   82 |         node.right = new_node(node, value)
vlib/datatypes/bstree.v:84:23: error: cannot use operator `>` with `Result[[]Token, Err[string]]`
   82 |         node.right = new_node(node, value)
   83 |         return true
   84 |     } else if node.value > value {
      |                          ^
   85 |         if unsafe { node.left != 0 } && node.left.is_init {
   86 |             return bst.insert_helper(mut node.left, value)
vlib/datatypes/bstree.v:86:28: error: unknown type `Token`.
Did you mean `Ok[[]Token]`?
   84 |     } else if node.value > value {
   85 |         if unsafe { node.left != 0 } && node.left.is_init {
   86 |             return bst.insert_helper(mut node.left, value)
      |                                     ^
   87 |         }
   88 |         node.left = new_node(node, value)
vlib/datatypes/bstree.v:96:28: error: unknown type `Token`.
Did you mean `Ok[[]Token]`?
   94 | // contains checks if an element with a given `value` is inside the BST.
   95 | pub fn (bst &BSTree[T]) contains(value T) bool {
   96 |     return bst.contains_helper(bst.root, value)
      |                               ^
   97 | }
   98 |
vlib/datatypes/bstree.v:105:16: error: cannot use operator `<` with `Result[[]Token, Err[string]]`
  103 |         return false
  104 |     }
  105 |     if node.value < value {
      |                   ^
  106 |         return bst.contains_helper(node.right, value)
  107 |     } else if node.value > value {
vlib/datatypes/bstree.v:106:29: error: unknown type `Token`.
Did you mean `Ok[[]Token]`?
  104 |     }
  105 |     if node.value < value {
  106 |         return bst.contains_helper(node.right, value)
      |                                   ^
  107 |     } else if node.value > value {
  108 |         return bst.contains_helper(node.left, value)
vlib/datatypes/bstree.v:107:23: error: cannot use operator `>` with `Result[[]Token, Err[string]]`
  105 |     if node.value < value {
  106 |         return bst.contains_helper(node.right, value)
  107 |     } else if node.value > value {
      |                          ^
  108 |         return bst.contains_helper(node.left, value)
  109 |     }
vlib/datatypes/bstree.v:108:29: error: unknown type `Token`.
Did you mean `Ok[[]Token]`?
  106 |         return bst.contains_helper(node.right, value)
  107 |     } else if node.value > value {
  108 |         return bst.contains_helper(node.left, value)
      |                                   ^
  109 |     }
  110 |     assert node.value == value
vlib/datatypes/bstree.v:116:17: error: unknown type `Token`.
Did you mean `Ok[[]Token]`?
  114 | // remove removes an element with `value` from the BST.
  115 | pub fn (mut bst BSTree[T]) remove(value T) bool {
  116 |     if bst.is_empty() {
      |                    ^
  117 |         return false
  118 |     }
vlib/datatypes/bstree.v:119:26: error: unknown type `Token`.
Did you mean `Ok[[]Token]`?
  117 |         return false
  118 |     }
  119 |     return bst.remove_helper(mut bst.root, value, false)
      |                             ^
  120 | }
  121 |
vlib/datatypes/bstree.v:130:42: error: unknown type `Token`.
Did you mean `Ok[[]Token]`?
  128 |             // In order to remove the element we need to bring up as parent the max of the
  129 |             // left sub-tree.
  130 |             mut max_node := bst.get_max_from_right(node.left)
      |                                                   ^
  131 |             node.bind(mut max_node, true)
  132 |         } else if unsafe { node.right != 0 } && node.right.is_init {
vlib/datatypes/bstree.v:131:13: error: unknown type `Token`.
Did you mean `Ok[[]Token]`?
  129 |             // left sub-tree.
  130 |             mut max_node := bst.get_max_from_right(node.left)
  131 |             node.bind(mut max_node, true)
      |                      ^
  132 |         } else if unsafe { node.right != 0 } && node.right.is_init {
  133 |             // Bring up the element with the minimum value in the right sub-tree.
vlib/datatypes/bstree.v:134:41: error: unknown type `Token`.
Did you mean `Ok[[]Token]`?
  132 |         } else if unsafe { node.right != 0 } && node.right.is_init {
  133 |             // Bring up the element with the minimum value in the right sub-tree.
  134 |             mut min_node := bst.get_min_from_left(node.right)
      |                                                  ^
  135 |             node.bind(mut min_node, false)
  136 |         } else {
vlib/datatypes/bstree.v:135:13: error: unknown type `Token`.
Did you mean `Ok[[]Token]`?
  133 |             // Bring up the element with the minimum value in the right sub-tree.
  134 |             mut min_node := bst.get_min_from_left(node.right)
  135 |             node.bind(mut min_node, false)
      |                      ^
  136 |         } else {
  137 |             mut parent := node.parent
vlib/datatypes/bstree.v:148:16: error: cannot use operator `<` with `Result[[]Token, Err[string]]`
  146 |     }
  147 | 
  148 |     if node.value < value {
      |                   ^
  149 |         return bst.remove_helper(mut node.right, value, false)
  150 |     }
vlib/datatypes/bstree.v:149:27: error: unknown type `Token`.
Did you mean `Ok[[]Token]`?
  147 | 
  148 |     if node.value < value {
  149 |         return bst.remove_helper(mut node.right, value, false)
      |                                 ^
  150 |     }
  151 |     return bst.remove_helper(mut node.left, value, true)
vlib/datatypes/bstree.v:151:26: error: unknown type `Token`.
Did you mean `Ok[[]Token]`?
  149 |         return bst.remove_helper(mut node.right, value, false)
  150 |     }
  151 |     return bst.remove_helper(mut node.left, value, true)
      |                             ^
  152 | }
  153 |
vlib/datatypes/bstree.v:163:31: error: unknown type `Token`.
Did you mean `Ok[[]Token]`?
  161 |         return node
  162 |     }
  163 |     return bst.get_max_from_right(right_node)
      |                                  ^
  164 | }
  165 |
vlib/datatypes/bstree.v:175:30: error: unknown type `Token`.
Did you mean `Ok[[]Token]`?
  173 |         return node
  174 |     }
  175 |     return bst.get_min_from_left(left_node)
      |                                 ^
  176 | }
  177 |
vlib/datatypes/bstree.v:185:18: error: unknown type `Token`.
Did you mean `Ok[[]Token]`?
  183 | // in_order_traversal traverses the BST in order, and returns the result as an array.
  184 | pub fn (bst &BSTree[T]) in_order_traversal() []T {
  185 |     mut result := []T{}
      |                     ^
  186 |     bst.in_order_traversal_helper(bst.root, mut result)
  187 |     return result
vlib/datatypes/bstree.v:186:31: error: unknown type `Token`.
Did you mean `Ok[[]Token]`?
  184 | pub fn (bst &BSTree[T]) in_order_traversal() []T {
  185 |     mut result := []T{}
  186 |     bst.in_order_traversal_helper(bst.root, mut result)
      |                                  ^
  187 |     return result
  188 | }
vlib/datatypes/bstree.v:195:31: error: unknown type `Token`.
Did you mean `Ok[[]Token]`?
  193 |         return
  194 |     }
  195 |     bst.in_order_traversal_helper(node.left, mut result)
      |                                  ^
  196 |     result << node.value
  197 |     bst.in_order_traversal_helper(node.right, mut result)
vlib/datatypes/bstree.v:197:31: error: unknown type `Token`.
Did you mean `Ok[[]Token]`?
  195 |     bst.in_order_traversal_helper(node.left, mut result)
  196 |     result << node.value
  197 |     bst.in_order_traversal_helper(node.right, mut result)
      |                                  ^
  198 | }
  199 |
vlib/datatypes/bstree.v:202:18: error: unknown type `Token`.
Did you mean `Ok[[]Token]`?
  200 | // post_order_traversal traverses the BST in post order, and returns the result in an array.
  201 | pub fn (bst &BSTree[T]) post_order_traversal() []T {
  202 |     mut result := []T{}
      |                     ^
  203 |     bst.post_order_traversal_helper(bst.root, mut result)
  204 |     return result
vlib/datatypes/bstree.v:203:33: error: unknown type `Token`.
Did you mean `Ok[[]Token]`?
  201 | pub fn (bst &BSTree[T]) post_order_traversal() []T {
  202 |     mut result := []T{}
  203 |     bst.post_order_traversal_helper(bst.root, mut result)
      |                                    ^
  204 |     return result
  205 | }
vlib/datatypes/bstree.v:214:33: error: unknown type `Token`.
Did you mean `Ok[[]Token]`?
  212 |     }
  213 | 
  214 |     bst.post_order_traversal_helper(node.left, mut result)
      |                                    ^
  215 |     bst.post_order_traversal_helper(node.right, mut result)
  216 |     result << node.value
vlib/datatypes/bstree.v:215:33: error: unknown type `Token`.
Did you mean `Ok[[]Token]`?
  213 | 
  214 |     bst.post_order_traversal_helper(node.left, mut result)
  215 |     bst.post_order_traversal_helper(node.right, mut result)
      |                                    ^
  216 |     result << node.value
  217 | }
vlib/datatypes/bstree.v:221:18: error: unknown type `Token`.
Did you mean `Ok[[]Token]`?
  219 | // pre_order_traversal traverses the BST in pre order, and returns the result as an array.
  220 | pub fn (bst &BSTree[T]) pre_order_traversal() []T {
  221 |     mut result := []T{}
      |                     ^
  222 |     bst.pre_order_traversal_helper(bst.root, mut result)
  223 |     return result
vlib/datatypes/bstree.v:222:32: error: unknown type `Token`.
Did you mean `Ok[[]Token]`?
  220 | pub fn (bst &BSTree[T]) pre_order_traversal() []T {
  221 |     mut result := []T{}
  222 |     bst.pre_order_traversal_helper(bst.root, mut result)
      |                                   ^
  223 |     return result
  224 | }
vlib/datatypes/bstree.v:233:32: error: unknown type `Token`.
Did you mean `Ok[[]Token]`?
  231 |     }
  232 |     result << node.value
  233 |     bst.pre_order_traversal_helper(node.left, mut result)
      |                                   ^
  234 |     bst.pre_order_traversal_helper(node.right, mut result)
  235 | }
vlib/datatypes/bstree.v:234:32: error: unknown type `Token`.
Did you mean `Ok[[]Token]`?
  232 |     result << node.value
  233 |     bst.pre_order_traversal_helper(node.left, mut result)
  234 |     bst.pre_order_traversal_helper(node.right, mut result)
      |                                   ^
  235 | }
  236 |
vlib/datatypes/bstree.v:246:16: error: cannot use operator `<` with `Result[[]Token, Err[string]]`
  244 |     }
  245 | 
  246 |     if node.value < value {
      |                   ^
  247 |         return bst.get_node(node.right, value)
  248 |     }
vlib/datatypes/bstree.v:247:22: error: unknown type `Token`.
Did you mean `Ok[[]Token]`?
  245 | 
  246 |     if node.value < value {
  247 |         return bst.get_node(node.right, value)
      |                            ^
  248 |     }
  249 |     return bst.get_node(node.left, value)
vlib/datatypes/bstree.v:249:21: error: unknown type `Token`.
Did you mean `Ok[[]Token]`?
  247 |         return bst.get_node(node.right, value)
  248 |     }
  249 |     return bst.get_node(node.left, value)
      |                        ^
  250 | }
  251 |
vlib/datatypes/bstree.v:260:17: error: unknown type `Token`.
Did you mean `Ok[[]Token]`?
  258 | //```
  259 | pub fn (bst &BSTree[T]) to_left(value T) !T {
  260 |     if bst.is_empty() {
      |                    ^
  261 |         return error('BSTree is empty')
  262 |     }
vlib/datatypes/bstree.v:263:22: error: unknown type `Token`.
Did you mean `Ok[[]Token]`?
  261 |         return error('BSTree is empty')
  262 |     }
  263 |     node := bst.get_node(bst.root, value)
      |                         ^
  264 |     if !node.is_init {
  265 |         return error('BSTree is not initialized')
vlib/datatypes/bstree.v:279:17: error: unknown type `Token`.
Did you mean `Ok[[]Token]`?
  277 | //```
  278 | pub fn (bst &BSTree[T]) to_right(value T) !T {
  279 |     if bst.is_empty() {
      |                    ^
  280 |         return error('BSTree is empty')
  281 |     }
vlib/datatypes/bstree.v:282:22: error: unknown type `Token`.
Did you mean `Ok[[]Token]`?
  280 |         return error('BSTree is empty')
  281 |     }
  282 |     node := bst.get_node(bst.root, value)
      |                         ^
  283 |     if !node.is_init {
  284 |         return error('BSTree is not initialized')
vlib/datatypes/bstree.v:293:17: error: unknown type `Token`.
Did you mean `Ok[[]Token]`?
  291 | // Time complexity O(N) if the BST is not balanced
  292 | pub fn (bst &BSTree[T]) max() !T {
  293 |     if bst.is_empty() {
      |                    ^
  294 |         return error('BSTree is empty')
  295 |     }
vlib/datatypes/bstree.v:296:31: error: unknown type `Token`.
Did you mean `Ok[[]Token]`?
  294 |         return error('BSTree is empty')
  295 |     }
  296 |     max := bst.get_max_from_right(bst.root)
      |                                  ^
  297 |     if !max.is_init {
  298 |         return error('BSTree is not initialized')
vlib/datatypes/bstree.v:306:17: error: unknown type `Token`.
Did you mean `Ok[[]Token]`?
  304 | // Time complexity O(N) if the BST is not balanced.
  305 | pub fn (bst &BSTree[T]) min() !T {
  306 |     if bst.is_empty() {
      |                    ^
  307 |         return error('BSTree is empty')
  308 |     }
vlib/datatypes/bstree.v:309:30: error: unknown type `Token`.
Did you mean `Ok[[]Token]`?
  307 |         return error('BSTree is empty')
  308 |     }
  309 |     min := bst.get_min_from_left(bst.root)
      |                                 ^
  310 |     if !min.is_init {
  311 |         return error('BSTree is not initialized')