docs: def solve_value(self, value, resource):
          """Solve a resource with a value, without coercing.
  
          Arguments
          ---------
          value : ?
              A value to solve in combination with the given resource. The first filter of the
              resource will be applied on this value (next filters on the result of the previous
              filter).
          resource : dataql.resources.Resource
              An instance of a subclass of ``Resource`` to solve with the given value.
  
          Returns
          -------
          The result of all filters applied on the value for the first filter, and result of the
          previous filter for next filters.
  
          Example
          -------
  
          >>> from dataql.solvers.registry import Registry
          >>> registry = Registry()
          >>> from datetime import date
          >>> registry.register(date, allow_class=True)
          >>> registry.register(str)
          >>> class MySolver(Solver):
          ...     def coerce(self, value, resource): return value
          >>> solver = MySolver(registry)
          >>> from dataql.resources import Filter, NamedArg, PosArg, SliceFilter
          >>> field = Field(None,
          ...     filters=[
          ...         Filter(name='fromtimestamp', args=[PosArg(1433109600)]),
          ...         Filter(name='replace', args=[NamedArg('year', '=', 2014)]),
          ...         Filter(name='strftime', args=[PosArg('%F')]),
          ...         Filter(name='replace', args=[PosArg('2014'), PosArg('2015')]),
          ...     ]
          ... )
          >>> solver.solve_value(date, field)
          '2015-06-01'
          >>> solver.solve_value(None, field)
  
          >>> d = {'foo': {'date': date(2015, 6, 1)}, 'bar': {'date': None}, 'baz': [{'date': None}]}
          >>> registry.register(dict)
          >>> solver.solve_value(d, Field(None, filters=[
          ...     Filter(name='foo'),
          ...     Filter(name='date'),
          ...     Filter(name='strftime', args=[PosArg('%F')]),
          ... ]))
          '2015-06-01'
          >>> solver.solve_value(d, Field(None, filters=[
          ...     Filter(name='bar'),
          ...     Filter(name='date'),
          ...     Filter(name='strftime', args=[PosArg('%F')]),
          ... ]))
  
          >>> solver.solve_value(d, Field(None, filters=[
          ...     Filter(name='baz'),
          ...     SliceFilter(0),
          ...     Filter(name='date'),
          ...     Filter(name='strftime', args=[PosArg('%F')]),
          ... ]))
  
          # Example of how to raise a ``CannotSolve`` exception.
          >>> from dataql.solvers.exceptions import CannotSolve
          >>> raise CannotSolve(solver, Field('fromtimestamp'), date)  # doctest: +ELLIPSIS
          Traceback (most recent call last):
          dataql...CannotSolve: Solver `<MySolver>` was not able to solve...`<Field[fromtimestamp]>`.
  
          """
  
          # The given value is the starting point on which we apply the first filter.
          result = value
  
          # Apply filters one by one on the previous result.
          if result is not None:
              for filter_ in resource.filters:
                  result = self.registry.solve_filter(result, filter_)
                  if result is None:
                      break
  
          return result