quickdudley/namepick - Change AOO3FCSGBMVD5YFMP2JO2P7ACWZF7IS6G3EI75GRYOIS4EIKPKHQC

Cargo clippy, tweaks, etc

Created by quickdudley on January 19, 2022

AOO3FCSGBMVD5YFMP2JO2P7ACWZF7IS6G3EI75GRYOIS4EIKPKHQC

Dependencies

In channels

main

Change contents

Insertion in src/pick.rs at line 14 [4.32]
[3.203]
[4.277]
```
type IDedName = (String, i64);
```

Replacement in src/pick.rs at line 22 [4.32]

B:BD[3.322] → [3.322:367]

    let (ntx, mut nrx) = mpsc::channel(256);

[3.322]

[3.367]

    let (ntx, mut nrx) = mpsc::channel(count as usize / 2 + count as usize % 2);

Replacement in src/pick.rs at line 28 [4.32]

B:BD[3.554] → [3.554:935]

            while let Some(name) = incoming.recv().await {
                let (id, fresh) = match gdb.add_name(name.clone()).await {
                    Ok(r) => r,
                    Err(_) => break,
                };
                if fresh {
                    match tg.send((name, id)).await {
                        Ok(_) => (),
                        Err(_) => break,

[3.554]

[3.935]

            'getpages: while let Some(names) = incoming.recv().await {
                let handles: Vec<_> = names
                    .into_iter()
                    .map(|name| {
                        let xdb = gdb.clone();
                        let xg = tg.clone();
                        tokio::spawn(async move {
                            if let Ok((id, true)) =
                                xdb.add_name(name.clone()).await
                            {
                                xg.send((name, id)).await.is_ok()
                            } else {
                                false
                            }
                        })
                    })
                    .collect();
                for h in handles {
                    match h.await {
                        Ok(true) => (),
                        _ => break 'getpages,

Replacement in src/pick.rs at line 50 [4.32]
B:BD[3.957] → [3.957:976]
```
                };
```
[3.957]
[3.976]
```
                }
```

Replacement in src/pick.rs at line 80 [4.32]

B:BD[5.153] → [2.28:99]

    let mut comparator = CompareContext::new(&db, &mut stderr).await?;

[5.153]

[3.1875]

    let mut comparator = CompareContext::new(db.clone(), &mut stderr).await?;

Replacement in src/pick.rs at line 95 [4.32]

B:BD[3.2268] → [3.2268:2365]

        let mut i: *mut (String, i64) = &mut shortlist[0];
        let j: *mut (String, i64) = {

[3.2268]

[3.2365]

        let mut i: *mut IDedName = &mut shortlist[0];
        let j: *mut IDedName = {

Replacement in src/pick.rs at line 100 [4.32]

B:BD[3.2451] → [6.46:122]

        let pivot: *mut (String, i64) = &mut shortlist[count as usize - 1];

[3.2451]

[3.2523]

        let pivot: *mut IDedName =
            unsafe { i.offset(j.offset_from(i) / 2) };

Replacement in src/pick.rs at line 111 [4.32]

B:BD[6.170] → [2.100:171]

        let mut stack: Vec<(*mut (String, i64), *mut (String, i64))> =

[6.170]

[2.171]

        let mut stack: Vec<(*mut IDedName, *mut IDedName)> =

Replacement in src/pick.rs at line 131 [4.32]
∅:D[7.146] → [3.2807:2836]
B:BD[3.2807] → [3.2807:2836]
```
    db: &'a AsyncConnection,
```
[7.146]
[7.147]
```
    db: AsyncConnection,
```
Replacement in src/pick.rs at line 146 [4.32]
B:BD[2.309] → [2.309:342]
```
        db: &'a AsyncConnection,
```
[2.309]
[2.342]
```
        db: AsyncConnection,
```

Replacement in src/pick.rs at line 166 [4.32]

B:BD[3.3037] → [3.3037:3101]

B:BD[3.3101] → [2.631:666]

∅:D[2.666] → [3.3140:3181]

B:BD[3.3140] → [3.3140:3181]

        lo: *mut (String, i64),
        hi: *mut (String, i64),
        pivot: *mut (String, i64),
    ) -> DynResult<*mut (String, i64)> {

[3.3037]

[2.667]

        lo: *mut IDedName,
        hi: *mut IDedName,
        pivot: *mut IDedName,
    ) -> DynResult<*mut IDedName> {

Replacement in src/pick.rs at line 197 [4.32]

B:BD[3.4046] → [3.4046:4100]

        a: &(String, i64),
        b: &(String, i64),

[3.4046]

[3.4100]

        a: &IDedName,
        b: &IDedName,

Replacement in src/grid.rs at line 15 [2.3318]

B:BD[2.3533] → [2.3533:3595]

    pub fn column<'a>(&'a self, x: usize) -> BoolColumn<'a> {

[2.3533]

[2.3595]

    pub fn column(&self, x: usize) -> BoolColumn<'_> {

Replacement in src/grid.rs at line 19 [2.3318]

B:BD[2.3635] → [2.3635:3691]

    pub fn row<'a>(&'a self, y: usize) -> BoolRow<'a> {

[2.3635]

[2.3691]

    pub fn row(&self, y: usize) -> BoolRow<'_> {

Replacement in src/grid.rs at line 247 [2.3318]

B:BD[2.10515] → [2.10515:10581]

                std::mem::replace(&mut self.content, Vec::new()),

[2.10515]

[2.10581]

                std::mem::take(&mut self.content),

Replacement in src/gather.rs at line 22 [8.87]

B:BD[8.485] → [8.485:559]

pub fn all_names(filter: Gender) -> tokio::sync::mpsc::Receiver<String> {

[8.485]

[8.559]

pub fn all_names(filter: Gender) -> tokio::sync::mpsc::Receiver<Vec<String>> {

Replacement in src/gather.rs at line 29 [8.87]

∅:D[9.473] → [10.651:712]

B:BD[10.651] → [10.651:712]

                Err(err) => {
                    dbg!(err);

[9.473]

[9.474]

                Err(_) => {

Replacement in src/gather.rs at line 38 [8.87]

B:BD[9.698] → [9.698:904]

                    for (name, gender) in page {
                        if filter.allow(&gender) {
                            tx.send(name).await.unwrap();
                        }
                    }

[9.698]

[9.904]

                    match tx
                        .send(
                            page.into_iter()
                                .filter_map(|(name, gender)| {
                                    if filter.allow(&gender) {
                                        Some(name)
                                    } else {
                                        None
                                    }
                                })
                                .collect(),
                        )
                        .await
                    {
                        Ok(_) => (),
                        Err(_) => break,
                    };