A lot of resources wasted on superfluous eyecandy. Honestly, I found a lot of the stylized icons illegible at times. When I was a newbie wanting to try out Arch the “safe way,” I resorted to the Garuda barebones version. It felt much more sane for a daily driver.

cool!

impl Iterator for YourType ?

Sounds like a lot of hype garbage and VC cash grab. Instead of putting their efforts into improving the Rust ML landscape, they chose to half-ass Rust into Python.

I guess, I want to focus on a good seed ratio.

You can try contacting annas-archive.org

Helix is genuinely a great editor. Even the AppImage picks up LSP servers present on the system. If it works good enough for you, awesome! Don’t stop using it because someone sang praises of neovim.

lol forgot the cases where there might be multiple nested braces!

Rust solution:

use std::cmp::min;
use std::ops::Range;

fn completer(bracket: char) -> char {
    match bracket {
        ')' => '(',
        '}' => '{',
        ']' => '[',
        _ => unreachable!(),
    }
}

pub struct Char {
    index: usize,
    value: char,
}

fn main() {
    let input: String = std::env::args().nth(1).unwrap();
    let mut longest = Range::default();
    {
        let mut current = Range::default();
        let mut stack: Vec = Vec::with_capacity(input.len() << 1);
        let mut streak = false;
        for (i, c) in input.chars().enumerate() {
            match c {
                ']' | '}' | ')' => {
                    let matched = stack
                        .last()
                        .map(|other| completer(c) == other.value)
                        .unwrap_or_default();
                    if matched {
                        current.start = if streak {
                            min(current.start, stack.pop().unwrap().index)
                        } else {
                            stack.pop().unwrap().index
                        };
                        current.end = i;
                        streak = true;
                    } else {
                        stack.clear();
                        if longest.len() < current.len() {
                            longest = current;
                        }
                        current = Range {
                            start: i + 1,
                            end: i + 1,
                        };
                        streak = false;
                    }
                }
                '[' | '{' | '(' => {
                    stack.push(Char { index: i, value: c });
                }
                _ => {}
            };
        }

        if streak {
            longest = current;
        }
    }

    if longest.start != longest.end {
        longest.end += 1;
    }
    println!("{}", &input[longest]);
}

Also available at: https://pastebin.com/EJsLYPqQ

Rust solution:

fn completer(bracket: char) -> char {
    match bracket {
        '[' => ']',
        '{' => '}',
        '(' => ')',
        ')' => '(',
        '}' => '{',
        ']' => '[',
        _ => unreachable!(),
    }
}

fn rec(v: &mut Vec, stack: &mut Vec, depth: usize) {
    // If we have more characters in the stack to complete
    // than the space avaiable, bail!
    if stack.len() > depth {
        return;
    }

    if depth == 0 {
        let output: String = v.iter().collect();
        println!("{}", output);
        return;
    }

    for b in &['[', '{', '('] {
        v.push(*b);
        stack.push(*b);
        rec(v, stack, depth - 1);
        stack.pop();
        v.pop();
    }

    if let Some(c) = stack.pop() {
        v.push(completer(c));
        rec(v, stack, depth - 1);
        stack.push(c);
        v.pop();
    }
}

fn main() {
    let depth: usize = std::env::args().nth(1).unwrap().parse().unwrap();
    let mut v = Vec::with_capacity(depth);
    let mut s = Vec::with_capacity(depth / 2);
    rec(&mut v, &mut s, depth);
}

Hope you enjoy this!

Edit: Lemmy makes the usize in angle brackets disappear after parse::. Idk what to do.

Edit: I kinda fixed it by assigning the type as a part of the variable definition.

Note to self: the angle bracket problem persists nonetheless.

Rust solution:

fn main() {
    let input = std::env::args().skip(1).next().unwrap();
    let mut stack = Vec::with_capacity(input.len() / 4);
    for ch in input.chars() {
        match (ch, stack.last()) {
            ('}', Some(&'{')) | (']', Some(&'[')) | (')', Some(&'(')) => {
                stack.pop();
            }
            _ => stack.push(ch),
        }
    }
    let output: String = stack.iter().collect();
    println!("{}", output);
}

Also available at: https://pastebin.com/YWw4ydSY

The first one is reminiscent of Tom Scott’s Onosecond.

Or an Arc<Mutex<T>> if dealing with threads.

This is the way

Try out helix. It has a lot of sane defaults baked into it, treesitter, LSP support, etc.

*Laughs in Option<T>*

If you’re not strictly looking for GUI tools, you might want to look into httpie or the http command built into the nu shell.

Ublock Origin should give you a lot of mileage. However, consider using Fennec F-Droid because it allows other extensions like Tampermonkey, which you can use to install userscripts.

Monoservices and microliths. I swear I didn’t make those up.

Seems like you can remove the header and the sidebar HTML nodes, set the width of the pdfViewer class to 100% and hit Ctrl+P. Alternatively you may save one “page” at a time using Ctrl+Shift+S as described by @tumulus_scrolls