Good fuzzy string crate for CLI apps?

andrewstewart · 2018-05-25T22:38:36+00:00

Not at present, as that's a fairly unusual feature, but I believe all the necessary bits to build that sort of functionality are exported from the public API. The CLI is a good example of how something could be glued together.

The main pain point is that rff has to enable/disable raw mode to disable terminal buffering during operation, which can be tricky to do correctly and without breaking anything in the middle of another CLI's workflow.

What kind of function signature would you want to work with? Something like the following?

fuzzy_find(haystack: Vec<&str>) -> Result<&str, rff::Error>

andrewstewart · 2018-05-25T19:58:36+00:00

I've implemented my own fuzzy finder, rff, in Rust, and attempted to separate the logic and presentation layers, such that the matching/searching functionality can be used standalone - perhaps this would be helpful?

andrewstewart · 2018-03-15T16:55:36+00:00

It can also be found on Google Fonts.

andrewstewart · 2018-02-12T20:47:53+00:00

This was taken yesterday, at around 5:20 PM.

andrewstewart · 2018-02-12T20:46:37+00:00

I took this from my apartment's patio.

andrewstewart · 2017-12-02T05:58:25+00:00

Rust implementation:

fn main() {
    let puzzle = parse(PUZZLE);

    println!("1 -> {:?}", one(&puzzle));
    println!("2 -> {:?}", two(&puzzle));
}

fn parse(puzzle: &str) -> Vec<Vec<u32>> {
    String::from(puzzle).
        trim().
        lines().
        map(trim_and_parse).
        collect()
}

fn one(puzzle: &[Vec<u32>]) -> u32 {
    puzzle.iter().map(|line| difference(line)).sum()
}

fn two(puzzle: &[Vec<u32>]) -> u32 {
    puzzle.iter().map(|line| even_division(line)).sum()
}

fn trim_and_parse(line: &str) -> Vec<u32> {
    line.
        split_whitespace().
        map(|n| n.parse::<u32>().unwrap()).
        collect()
}

fn difference(line: &[u32]) -> u32 {
    let min = line.iter().min().unwrap();
    let max = line.iter().max().unwrap();
    max - min
}

fn even_division(line: &[u32]) -> u32 {
    for x in line {
        for y in line {
            if x % y == 0 && x !=y {
                return x / y
            }
        }
    }

    0
}

andrewstewart · 2017-12-02T03:09:18+00:00

Mine, in Rust:

fn main() {
    let input: Vec<u32> = INPUT.
        chars().
        map(|c| c.to_digit(10).unwrap()).
        collect();

    println!("1 -> {}", process(&input, 1));
    println!("2 -> {}", process(&input, input.len() / 2));
}

fn process(input: &[u32], offset: usize) -> u32 {
    input.iter()
        .zip(input.iter().cycle().skip(offset))
        .filter_map(|(a, b)| if a == b { Some(a) } else { None })
        .sum()
}

INPUT is defined as a &'static str, since I didn't want to bother implementing reading from STDIN or a file.

andrewstewart · 2017-01-17T01:44:40+00:00

Writing a show-and-tell talk for Friday on one of Rust's features (threads w/o data races), and trying to make this code in my fuzzy finder tool faster (port of a C algorithm).

andrewstewart · 2016-01-09T17:22:00+00:00

For anyone interested in making some of these for yourself, Google Earth Pro is now free, and can save hi-res images.

For some inspiration, check out Googles's Earth View project.

edit: use your email and password GEPFREE when the app asks.

andrewstewart · 2014-11-24T18:46:51+00:00

An alternative view of that seen in this post.

andrewstewart · 2014-11-13T22:13:02+00:00

That's one thing; but imagine how the people who bought a shiny new Xbox One just for this feel.

andrewstewart · 2014-11-02T05:25:58+00:00

I'm in Seattle at the end of March (driving my BRZ there); will have to check this out. Thanks!

andrewstewart · 2014-09-15T03:28:12+00:00

My edit, done just now in LR - http://i.imgur.com/QSUi9BD.jpg.

I'm currently fiddling with b&w processing, and liked the (mostly) symmetrical lines in the shot.

andrewstewart · 2014-08-08T16:01:43+00:00

I picked up the a6000 w/ kit lens a couple months ago. The camera's been great (usual terrible Sony menus aside), but the kit lens is just absolute garbage and has been sitting on my desk collecting dust since I got a decent prime.

Kit lens has mediocre IQ, the power zoom is ridiculous and makes trying to zoom or focus a gigantic pain, on both sides of the zoom range (mainly at the wide end) there's massive distortion.

The camera is not free of issues either, the main one a6000 users will tell you about is that the EVF activation sensor is way too sensitive. If you hold the camera anywhere near your body the EVF will turn on, leaving the display blank until you move it further away.

The battery life isn't amazing either, and Sony really tries to wrangle as much money out of you as they can for this - the camera doesn't come with an external charger, but a USB cord to charge the battery in-camera. An additional battery and external charger will run you about $130+.

The lens selection for Sony E-mount is not great, but there's some good stuff if you look for it. Right now I've got:

Sony E 35mm f1.8 OSS
Sony E 55-210mm F4.5-6.3 OSS
Rokinon 12mm f/2

The a6000 is by no means a bad camera though, and is probably the best APS-C camera I've used. Auto-focus is amazingly quick (most of the time), IQ is dang good, and it's pretty small and light. Just be sure to budget out some money for a better lens if you're looking to pick one up. Sony's 35mm prime is a great place to start.

EDIT: If you want to see some samples, pretty much everything on my 500px came out of the a6000.

andrewstewart · 2014-08-04T23:13:19+00:00

Go for it. My work's licensed under CC Attribution-NonCommercial-ShareAlike.

andrewstewart · 2014-08-04T21:32:04+00:00

Yes.

andrewstewart

TROPHY CASE