code: def request_handler(self, can_handle_func):
          # type: (Callable[[Input], bool]) -> Callable
          
          def wrapper(handle_func):
              if not callable(can_handle_func) or not callable(handle_func):
                  raise SkillBuilderException(
                      "Request Handler can_handle_func and handle_func "
                      "input parameters should be callable")
  
              class_attributes = {
                  "can_handle": lambda self, handler_input: can_handle_func(
                      handler_input),
                  "handle": lambda self, handler_input: handle_func(
                      handler_input)
              }
  
              request_handler_class = type(
                  "RequestHandler{}".format(
                      handle_func.__name__.title().replace("_", "")),
                  (AbstractRequestHandler,), class_attributes)
  
              self.add_request_handler(request_handler=request_handler_class())
          return wrapper
docs: Decorator that can be used to add request handlers easily to
          the builder.
  
          The can_handle_func has to be a Callable instance, which takes
          a single parameter and no varargs or kwargs. This is because
          of the RequestHandler class signature restrictions. The
          returned wrapper function can be applied as a decorator on any
          function that returns a response object by the skill. The
          function should follow the signature of the handle function in
          :py:class:`ask_sdk_runtime.dispatch_components.request_components.AbstractRequestHandler`
          class.
  
          :param can_handle_func: The function that validates if the
              request can be handled.
          :type can_handle_func: Callable[[Input], bool]
          :return: Wrapper function that can be decorated on a handle
              function.