docs: def resolve(
              self,
              configurable=None, conf=None, scope=None, ptype=None,
              parser=None, error=True, svalue=None,
              safe=None, besteffort=None
      ):
          """Resolve this parameter value related to a configurable and a
          configuration.
  
          Save error in this attribute `error` in case of failure.
  
          :param str svalue: serialized value too resolve. Default is this svalue.
          :param Configurable configurable: configurable to use for foreign
              parameter resolution.
          :param Configuration conf: configuration to use for
              cross-value resolution.
          :param dict scope: variables to use for local expression evaluation.
          :param type ptype: return type. Default is this ptype.
          :param parser: specific parser to use. Default this parser.
          :param bool error: raise an error if True (False by default).
          :param bool safe: if True (default) resolve without builtins functions.
          :param bool besteffort: best effort flag. Default is this besteffort.
          :return: newly resolved value.
          :raises: Parameter.Error for any raised exception.
          """
  
          result = self._value
  
          # if cached value is None and serialiazed value exists
          if self._value is None and self._svalue is not None:
  
              self._error = None  # nonify error.
  
              if ptype is None:
                  ptype = self.ptype
  
              if parser is None:  # init parser
                  parser = self.parser
  
              if svalue is None:
                  svalue = self._svalue
  
              if conf is None:  # init conf
                  conf = self.conf
  
              if configurable is None:  # init configurable
                  configurable = self.configurable
  
              if scope is None:
                  scope = self.scope
  
              else:
                  scope, selfscope = self.scope.copy(), scope
                  scope.update(selfscope)
  
              if safe is None:
                  safe = self.safe
  
              if besteffort is None:
                  besteffort = self.besteffort
  
              # parse value if str and if parser exists
              try:
                  result = self._value = parser(
                      svalue=svalue, conf=conf,
                      configurable=configurable, ptype=ptype,
                      scope=scope, safe=safe, besteffort=besteffort
                  )
  
              except Exception as ex:
  
                  self._error = ex
                  if error:
                      msg = 'Impossible to parse value ({0}) with {1}.'
                      msg = msg.format(self._svalue, self.parser)
                      reraise(Parameter.Error, Parameter.Error(msg))
  
          return result