Merge pull request RustPython#4228 from gilteunchoi/remove-old-doc-remark

remove most of old __doc__ remarks

Author: youknowone

stdlib/src/bisect.rs

@@ -57,14 +57,6 @@ mod _bisect {
         Ok((lo, hi))
     }
 
-    /// Return the index where to insert item x in list a, assuming a is sorted.
-    ///
-    /// The return value i is such that all e in a[:i] have e < x, and all e in
-    /// a[i:] have e >= x.  So if x already appears in the list, a.insert(x) will
-    /// insert just before the leftmost x already there.
-    ///
-    /// Optional args lo (default 0) and hi (default len(a)) bound the
-    /// slice of a to be searched.
     #[inline]
     #[pyfunction]
     fn bisect_left(
@@ -91,14 +83,6 @@ mod _bisect {
         Ok(lo)
     }
 
-    /// Return the index where to insert item x in list a, assuming a is sorted.
-    ///
-    /// The return value i is such that all e in a[:i] have e <= x, and all e in
-    /// a[i:] have e > x.  So if x already appears in the list, a.insert(x) will
-    /// insert just after the rightmost x already there.
-    ///
-    /// Optional args lo (default 0) and hi (default len(a)) bound the
-    /// slice of a to be searched.
     #[inline]
     #[pyfunction]
     fn bisect_right(
@@ -125,12 +109,6 @@ mod _bisect {
         Ok(lo)
     }
 
-    /// Insert item x in list a, and keep it sorted assuming a is sorted.
-    ///
-    /// If x is already in a, insert it to the left of the leftmost x.
-    ///
-    /// Optional args lo (default 0) and hi (default len(a)) bound the
-    /// slice of a to be searched.
     #[pyfunction]
     fn insort_left(BisectArgs { a, x, lo, hi, key }: BisectArgs, vm: &VirtualMachine) -> PyResult {
         let x = if let Some(ref key) = key {
@@ -151,12 +129,6 @@ mod _bisect {
         vm.call_method(&a, "insert", (index, x))
     }
 
-    /// Insert item x in list a, and keep it sorted assuming a is sorted.
-    ///
-    /// If x is already in a, insert it to the right of the rightmost x.
-    ///
-    /// Optional args lo (default 0) and hi (default len(a)) bound the
-    /// slice of a to be searched
     #[pyfunction]
     fn insort_right(BisectArgs { a, x, lo, hi, key }: BisectArgs, vm: &VirtualMachine) -> PyResult {
         let x = if let Some(ref key) = key {

stdlib/src/cmath.rs

@@ -1,8 +1,6 @@
 // TODO: Keep track of rust-num/num-complex/issues/2. A common trait could help with duplication
 //       that exists between cmath and math.
 pub(crate) use cmath::make_module;
-
-/// This module provides access to mathematical functions for complex numbers.
 #[pymodule]
 mod cmath {
     use crate::vm::{
@@ -21,57 +19,48 @@ mod cmath {
     #[pyattr(name = "nanj")]
     const NANJ: Complex64 = Complex64::new(0., std::f64::NAN);
 
-    /// Return argument, also known as the phase angle, of a complex.
     #[pyfunction]
     fn phase(z: ArgIntoComplex) -> f64 {
         z.arg()
     }
 
-    /// Convert a complex from rectangular coordinates to polar coordinates.
-    ///
-    /// r is the distance from 0 and phi the phase angle.
     #[pyfunction]
     fn polar(x: ArgIntoComplex) -> (f64, f64) {
         x.to_polar()
     }
 
-    /// Convert from polar coordinates to rectangular coordinates.
     #[pyfunction]
     fn rect(r: ArgIntoFloat, phi: ArgIntoFloat) -> Complex64 {
         Complex64::from_polar(*r, *phi)
     }
 
-    /// Checks if the real or imaginary part of z is infinite.
     #[pyfunction]
     fn isinf(z: ArgIntoComplex) -> bool {
         let Complex64 { re, im } = *z;
         re.is_infinite() || im.is_infinite()
     }
 
-    /// Return True if both the real and imaginary parts of z are finite, else False.
     #[pyfunction]
     fn isfinite(z: ArgIntoComplex) -> bool {
         z.is_finite()
     }
 
-    /// Checks if the real or imaginary part of z not a number (NaN)..
     #[pyfunction]
     fn isnan(z: ArgIntoComplex) -> bool {
         z.is_nan()
     }
 
-    /// Return the exponential value e**z.
     #[pyfunction]
     fn exp(z: ArgIntoComplex, vm: &VirtualMachine) -> PyResult<Complex64> {
         let z = *z;
         result_or_overflow(z, z.exp(), vm)
     }
-    /// Return the square root of z.
+
     #[pyfunction]
     fn sqrt(z: ArgIntoComplex) -> Complex64 {
         z.sqrt()
     }
-    /// Return the sine of z
+
     #[pyfunction]
     fn sin(z: ArgIntoComplex) -> Complex64 {
         z.sin()
@@ -82,7 +71,6 @@ mod cmath {
         z.asin()
     }
 
-    /// Return the cosine of z
     #[pyfunction]
     fn cos(z: ArgIntoComplex) -> Complex64 {
         z.cos()
@@ -93,9 +81,6 @@ mod cmath {
         z.acos()
     }
 
-    /// log(z[, base]) -> the logarithm of z to the given base.
-    ///
-    /// If the base not specified, returns the natural logarithm (base e) of z.
     #[pyfunction]
     fn log(z: ArgIntoComplex, base: OptionalArg<ArgIntoComplex>) -> Complex64 {
         // TODO: Complex64.log with a negative base yields wrong results.
@@ -110,55 +95,46 @@ mod cmath {
         )
     }
 
-    /// Return the base-10 logarithm of z.
     #[pyfunction]
     fn log10(z: ArgIntoComplex) -> Complex64 {
         z.log(10.0)
     }
 
-    /// Return the inverse hyperbolic cosine of z.
     #[pyfunction]
     fn acosh(z: ArgIntoComplex) -> Complex64 {
         z.acosh()
     }
 
-    /// Return the inverse tangent of z.
     #[pyfunction]
     fn atan(z: ArgIntoComplex) -> Complex64 {
         z.atan()
     }
 
-    /// Return the inverse hyperbolic tangent of z.
     #[pyfunction]
     fn atanh(z: ArgIntoComplex) -> Complex64 {
         z.atanh()
     }
 
-    /// Return the tangent of z.
     #[pyfunction]
     fn tan(z: ArgIntoComplex) -> Complex64 {
         z.tan()
     }
 
-    /// Return the hyperbolic tangent of z.
     #[pyfunction]
     fn tanh(z: ArgIntoComplex) -> Complex64 {
         z.tanh()
     }
 
-    /// Return the hyperbolic sin of z.
     #[pyfunction]
     fn sinh(z: ArgIntoComplex) -> Complex64 {
         z.sinh()
     }
 
-    /// Return the hyperbolic cosine of z.
     #[pyfunction]
     fn cosh(z: ArgIntoComplex) -> Complex64 {
         z.cosh()
     }
 
-    /// Return the inverse hyperbolic sine of z.
     #[pyfunction]
     fn asinh(z: ArgIntoComplex) -> Complex64 {
         z.asinh()
@@ -176,22 +152,6 @@ mod cmath {
         abs_tol: OptionalArg<ArgIntoFloat>,
     }
 
-    /// Determine whether two complex numbers are close in value.
-    ///
-    ///   rel_tol
-    ///     maximum difference for being considered "close", relative to the
-    ///     magnitude of the input values
-    ///   abs_tol
-    ///     maximum difference for being considered "close", regardless of the
-    ///     magnitude of the input values
-    ///
-    /// Return True if a is close in value to b, and False otherwise.
-    ///
-    /// For the values to be considered close, the difference between them must be
-    /// smaller than at least one of the tolerances.
-    ///
-    /// -inf, inf and NaN behave similarly to the IEEE 754 Standard. That is, NaN is
-    /// not close to anything, even itself. inf and -inf are only close to themselves.
     #[pyfunction]
     fn isclose(args: IsCloseArgs, vm: &VirtualMachine) -> PyResult<bool> {
         let a = *args.a;

stdlib/src/zlib.rs

@@ -62,7 +62,6 @@ mod zlib {
         )
     }
 
-    /// Compute an Adler-32 checksum of data.
     #[pyfunction]
     fn adler32(data: ArgBytesLike, begin_state: OptionalArg<PyIntRef>) -> u32 {
         data.with_ref(|data| {
@@ -74,7 +73,6 @@ mod zlib {
         })
     }
 
-    /// Compute a CRC-32 checksum of data.
     #[pyfunction]
     fn crc32(data: ArgBytesLike, begin_state: OptionalArg<PyIntRef>) -> u32 {
         crate::binascii::crc32(data, begin_state)

vm/src/builtins/bool.rs

@@ -71,11 +71,6 @@ impl PyObjectRef {
     }
 }
 
-/// bool(x) -> bool
-///
-/// Returns True when the argument x is true, False otherwise.
-/// The builtins True and False are the only two instances of the class bool.
-/// The class bool is a subclass of the class int, and cannot be subclassed.
 #[pyclass(name = "bool", module = false, base = "PyInt")]
 pub struct PyBool;
 

vm/src/builtins/dict.rs

@@ -31,15 +31,6 @@ use std::fmt;
 
 pub type DictContentType = dictdatatype::Dict;
 
-/// dict() -> new empty dictionary
-/// dict(mapping) -> new dictionary initialized from a mapping object's
-///    (key, value) pairs
-/// dict(iterable) -> new dictionary initialized as if via:
-///    d = {}
-///    for k, v in iterable:
-///        d\[k\] = v
-/// dict(**kwargs) -> new dictionary initialized with the name=value pairs
-///    in the keyword argument list.  For example:  dict(one=1, two=2)
 #[pyclass(module = false, name = "dict")]
 #[derive(Default)]
 pub struct PyDict {

vm/src/builtins/filter.rs

@@ -6,10 +6,6 @@ use crate::{
     Context, Py, PyObjectRef, PyPayload, PyResult, VirtualMachine,
 };
 
-/// filter(function or None, iterable) --> filter object
-///
-/// Return an iterator yielding those items of iterable for which function(item)
-/// is true. If function is None, return the items that are true.
 #[pyclass(module = false, name = "filter")]
 #[derive(Debug)]
 pub struct PyFilter {

vm/src/builtins/float.rs

@@ -22,7 +22,6 @@ use num_complex::Complex64;
 use num_rational::Ratio;
 use num_traits::{Signed, ToPrimitive, Zero};
 
-/// Convert a string or number to a floating point number, if possible.
 #[pyclass(module = false, name = "float")]
 #[derive(Debug, Copy, Clone, PartialEq)]
 pub struct PyFloat {

vm/src/builtins/int.rs

@@ -23,20 +23,6 @@ use num_traits::{One, Pow, PrimInt, Signed, ToPrimitive, Zero};
 use std::ops::{Div, Neg};
 use std::{fmt, ops::Not};
 
-/// int(x=0) -> integer
-/// int(x, base=10) -> integer
-///
-/// Convert a number or string to an integer, or return 0 if no arguments
-/// are given.  If x is a number, return x.__int__().  For floating point
-/// numbers, this truncates towards zero.
-///
-/// If x is not a number or if base is given, then x must be a string,
-/// bytes, or bytearray instance representing an integer literal in the
-/// given base.  The literal can be preceded by '+' or '-' and be surrounded
-/// by whitespace.  The base defaults to 10.  Valid bases are 0 and 2-36.
-/// Base 0 means to interpret the base from the string as an integer literal.
-/// >>> int('0b100', base=0)
-/// 4
 #[pyclass(module = false, name = "int")]
 #[derive(Debug)]
 pub struct PyInt {

vm/src/builtins/list.rs

@@ -22,10 +22,6 @@ use crate::{
 };
 use std::{fmt, ops::DerefMut};
 
-/// Built-in mutable sequence.
-///
-/// If no argument is given, the constructor creates a new empty list.
-/// The argument must be an iterable if specified.
 #[pyclass(module = false, name = "list")]
 #[derive(Default)]
 pub struct PyList {

vm/src/builtins/map.rs

@@ -8,10 +8,6 @@ use crate::{
     Context, Py, PyObjectRef, PyPayload, PyResult, VirtualMachine,
 };
 
-/// map(func, *iterables) --> map object
-///
-/// Make an iterator that computes the function using arguments from
-/// each of the iterables. Stops when the shortest iterable is exhausted.
 #[pyclass(module = false, name = "map")]
 #[derive(Debug)]
 pub struct PyMap {