code: def compile_expression(self, source, undefined_to_none=True):
          
          parser = Parser(self, source, state='variable')
          exc_info = None
          try:
              expr = parser.parse_expression()
              if not parser.stream.eos:
                  raise TemplateSyntaxError('chunk after expression',
                                            parser.stream.current.lineno,
                                            None, None)
              expr.set_environment(self)
          except TemplateSyntaxError:
              exc_info = sys.exc_info()
          if exc_info is not None:
              self.handle_exception(exc_info, source_hint=source)
          body = [nodes.Assign(nodes.Name('result', 'store'), expr, lineno=1)]
          template = self.from_string(nodes.Template(body, lineno=1))
          return TemplateExpression(template, undefined_to_none)
docs: A handy helper method that returns a callable that accepts keyword
          arguments that appear as variables in the expression.  If called it
          returns the result of the expression.
  
          This is useful if applications want to use the same rules as Jinja
          in template "configuration files" or similar situations.
  
          Example usage:
  
          >>> env = Environment()
          >>> expr = env.compile_expression('foo == 42')
          >>> expr(foo=23)
          False
          >>> expr(foo=42)
          True
  
          Per default the return value is converted to `None` if the
          expression returns an undefined value.  This can be changed
          by setting `undefined_to_none` to `False`.
  
          >>> env.compile_expression('var')() is None
          True
          >>> env.compile_expression('var', undefined_to_none=False)()
          Undefined
  
          .. versionadded:: 2.1