gh-39485:  Implement conversion from laurent series to rational function field
    
As in the title. I think this behavior makes sense because `QQ(RR(…))`
currently uses `.simplest_rational()` instead of like exact value (like
`x / 2^53` for some integer `x`), so it makes sense for similar
conversions to compute a good approximation too.

I cannot prove that this round-trips, however.

Note that currently conversion from power series `QQ[[x]]` to polynomial
ring `QQ[x]` truncates, because of implementation detail this leads to
conversion from `QQ[[x]]` to `Frac(QQ[x])` also truncates. I think this
is undesirable behavior because identical-looking elements in `QQ[[x]]`
versus `Frac(QQ[[x]]) = LaurentSeriesRing(QQ, "x")` has different
conversion behavior.

Elements which are already Laurent polynomial are preserved.

Side note: `.one()` is faster because it's cached

```sage
sage: R.<x> = QQ[]
sage: S = Frac(R)
sage: %timeit S.one()  # fast because it's cached
90.6 ns ± 1.27 ns per loop (mean ± std. dev. of 7 runs, 10,000,000 loops
each)
sage: ring_one = S.ring().one()
sage: %timeit S._element_class(S, ring_one, ring_one, coerce=False,
reduce=False)
3.42 μs ± 75 ns per loop (mean ± std. dev. of 7 runs, 100,000 loops
each)
```

Maybe this doesn't need to be explicitly written in the documentation
(users trying to do the conversion will just see the result)

There exists also <code>:meth:\`.PowerSeries_poly.pade\`</code> which
should probably be mentioned in the documentation.

Reverse direction (that one is a morphism):
#39365

Possible caveat:

```
sage: S(Frac(V)(1/(x+1))/(x^10))
1/(x^11 + x^10)
sage: S(Frac(V)(1/(x+1))/(x^30))
(-x^19 + x^18 - x^17 + x^16 - x^15 + x^14 - x^13 + x^12 - x^11 + x^10 -
x^9 + x^8 - x^7 + x^6 - x^5 + x^4 - x^3 + x^2 - x + 1)/x^30
```

It could be argued the latter would be simpler as `1/(x^31+x^30)`, but
then that way gives higher denominator degree.

### 📝 Checklist

<!-- Put an `x` in all the boxes that apply. -->

- [x] The title is concise and informative.
- [x] The description explains in detail what this PR is about.
- [x] I have linked a relevant issue or discussion.
- [x] I have created tests covering the changes.
- [ ] I have updated the documentation and checked the documentation
preview.

### ⌛ Dependencies

<!-- List all open PRs that this PR logically depends on. For example,
-->
<!-- - #12345: short description why this is a dependency -->
<!-- - #34567: ... -->
    
URL: #39485
Reported by: user202729
Reviewer(s): Travis Scrimshaw, user202729

Author: Release Manager

src/sage/rings/fraction_field.py

@@ -557,6 +557,40 @@ def is_exact(self):
         """
         return self.ring().is_exact()
 
+    def _convert_from_finite_precision_laurent_series(self, x):
+        """
+        Construct an element of this fraction field approximating a Laurent series.
+
+        INPUT:
+
+        - ``x`` -- a Laurent series, must have finite precision
+
+        OUTPUT: Element of ``self``
+
+        This internal method should not be used directly, use :meth:`__call__` instead,
+        which will delegates to :meth:`_element_constructor_`. There are some tests there.
+
+        .. NOTE::
+
+            Uses the algorithm described in `<https://mathoverflow.net/a/14874>`_.
+            This may be changed to use Berlekamp--Massey algorithm or something else
+            to compute Padé approximant in the future.
+
+        TESTS::
+
+            sage: F = QQ['x'].fraction_field()
+            sage: R = LaurentSeriesRing(QQ, 'x')
+            sage: f = ~R(x^2 + x + 3); f
+            1/3 - 1/9*x - 2/27*x^2 + 5/81*x^3 + ... + O(x^20)
+            sage: F._convert_from_finite_precision_laurent_series(f)
+            1/(x^2 + x + 3)
+        """
+        integral_part = self(x.truncate(1))
+        fractional_part = x.truncate_neg(1)
+        if fractional_part.is_zero():
+            return integral_part
+        return integral_part + ~self._convert_from_finite_precision_laurent_series(~fractional_part)
+
     def _element_constructor_(self, x, y=None, coerce=True):
         """
         Construct an element of this fraction field.
@@ -653,19 +687,94 @@ def _element_constructor_(self, x, y=None, coerce=True):
             sage: x = FF(elt)
             sage: F(x)
             -1/2/(a^2 + a)
+
+        Conversion from power series to rational function field gives an approximation::
+
+            sage: F.<x> = Frac(QQ['x'])
+            sage: R.<x> = QQ[[]]
+            sage: f = 1/(x+1)
+            sage: f.parent()
+            Power Series Ring in x over Rational Field
+            sage: F(f)
+            doctest:warning...
+            DeprecationWarning: Previously conversion from power series to rational function field truncates
+             instead of gives an approximation. Use .truncate() to recover the old behavior
+            See https://github.com/sagemath/sage/issues/39485 for details.
+            1/(x + 1)
+
+        Previously, the power series was truncated. To recover the old behavior, use
+        :meth:`~sage.rings.power_series_ring_element.PowerSeries.truncate`::
+
+            sage: F(f.truncate())
+            -x^19 + x^18 - x^17 + x^16 - x^15 + x^14 - x^13 + x^12 - x^11 + x^10 - x^9 + x^8 - x^7 + x^6 - x^5 + x^4 - x^3 + x^2 - x + 1
+
+        Conversion from Laurent series to rational function field gives an approximation::
+
+            sage: F.<x> = Frac(QQ['x'])
+            sage: R.<x> = QQ[[]]
+            sage: f = Frac(R)(1/(x+1))
+            sage: f.parent()
+            Laurent Series Ring in x over Rational Field
+            sage: F(f)
+            1/(x + 1)
+            sage: f = f.truncate(20); f  # infinite precision
+            1 - x + x^2 - x^3 + x^4 - x^5 + x^6 - x^7 + x^8 - x^9 + x^10 - x^11 + x^12 - x^13 + x^14 - x^15 + x^16 - x^17 + x^18 - x^19
+            sage: f.parent()
+            Laurent Series Ring in x over Rational Field
+            sage: F(f)
+            -x^19 + x^18 - x^17 + x^16 - x^15 + x^14 - x^13 + x^12 - x^11 + x^10 - x^9 + x^8 - x^7 + x^6 - x^5 + x^4 - x^3 + x^2 - x + 1
+            sage: f = 1/(x*(x+1))
+            sage: f.parent()
+            Laurent Series Ring in x over Rational Field
+            sage: F(f)
+            1/(x^2 + x)
+
+        ::
+
+            sage: K.<x> = FunctionField(QQ)
+            sage: R.<x> = QQ[[]]
+            sage: f = 1/(x+1); f.parent()
+            Power Series Ring in x over Rational Field
+            sage: K(f)
+            doctest:warning...
+            DeprecationWarning: Previously conversion from power series to rational function field truncates
+             instead of gives an approximation. Use .truncate() to recover the old behavior
+            See https://github.com/sagemath/sage/issues/39485 for details.
+            1/(x + 1)
+            sage: f = Frac(R)(1/(x+1))
+            sage: K(f)
+            1/(x + 1)
+            sage: f = 1/(x*(x+1))
+            sage: K(f)
+            1/(x^2 + x)
         """
         if isinstance(x, (list, tuple)) and len(x) == 1:
             x = x[0]
         if y is None:
             if parent(x) is self:
                 return x
+            from sage.rings.polynomial.polynomial_ring import PolynomialRing_generic
+            if isinstance(self.ring(), PolynomialRing_generic):
+                from sage.rings.power_series_ring_element import PowerSeries
+                from sage.rings.laurent_series_ring_element import LaurentSeries
+                if isinstance(x, PowerSeries):
+                    from sage.misc.superseded import deprecation
+                    deprecation(
+                        39485,
+                        "Previously conversion from power series to rational function field truncates "
+                        "instead of gives an approximation. Use .truncate() to recover the old behavior")
+                    x = x.laurent_series()
+                if isinstance(x, LaurentSeries):
+                    from sage.rings.infinity import infinity
+                    if x.prec() == infinity:
+                        return self(x.laurent_polynomial())
+                    return self._convert_from_finite_precision_laurent_series(x)
             ring_one = self.ring().one()
             try:
                 return self._element_class(self, x, ring_one, coerce=coerce)
             except (TypeError, ValueError):
                 pass
-            y = self._element_class(self, ring_one, ring_one,
-                                    coerce=False, reduce=False)
+            y = self.one()
         else:
             if parent(x) is self:
                 y = self(y)