docs: def evaluate(self, verbose=False, decode=True, passes=None, num_threads=1,
                   apply_experimental_transforms=True):
          """Evaluate the stored expression.
  
          Parameters
          ----------
          verbose : bool, optional
              Whether to print output for each Weld compilation step.
          decode : bool, optional
              Whether to decode the result
          passes : list, optional
              Which Weld optimization passes to apply
          num_threads : int, optional
              On how many threads to run Weld
          apply_experimental_transforms : bool
              Whether to apply the experimental Weld transforms.
  
          Returns
          -------
          numpy.ndarray
              Output of the evaluated expression.
  
          """
          if isinstance(self.weld_expr, WeldObject):
              old_context = dict(self.weld_expr.context)
  
              for key in self.weld_expr.context.keys():
                  if LazyResult._cache.contains(key):
                      self.weld_expr.context[key] = LazyResult._cache.get(key)
  
              evaluated = self.weld_expr.evaluate(to_weld_vec(self.weld_type,
                                                              self.ndim),
                                                  verbose,
                                                  decode,
                                                  passes,
                                                  num_threads,
                                                  apply_experimental_transforms)
  
              self.weld_expr.context = old_context
  
              return evaluated
          else:
              return self.weld_expr