zoea

Zoea is a crate to help baby Rustaceans get up and running.

It contains 'easy' buttons for common things like http get requests, key-value database persistence, and Natural Language Processing.

What do you call a baby crab? That's right! you call it a Zoea. Zoea is a package for baby Rustaceans, by a baby Rustacean.

Maybe coding is only a part-time thing for you. Maybe you have learned Python and want to try Rust because you heard all the hype. But then after spending two hours trying to make a simple http request and read the response you think "!$!@$!@# it- Rust is too hard."

If you have felt this way, zoea is for you.

Think of zoea as a collection of hackish, somewhat brittle 'easy buttons'

zoea does many different things, favoring ergonimics and simplicity over robustness and flexability. It helps you build something, achieve "proof of concept", and then mature into a more natively Rustacean approach. The only common thread between the various modules in zoea is they are all things the author has struggled with or tried to implement.

New in v0.1.0

The get_url functionality has been changed under the hood to use ureq instead of curl. This is a more pure-rust approach vs heritage C code. The method has also had an error wrapper applied.

easy http requests

use zoea::web::get_url;
fn main() {
    let url: String = String::from("http://dummy.restapiexample.com/api/v1/employees"); // can be &str or &String
    let resp_str: String = get_url(&url).unwrap();
    println!("url={}, response={}", &url, &resp_str);
}

easy matrix operations

The ::mtx module of Zoea adds some syntactic sugar around nalgebra to make it easy to create matrices of variable sizes and types. Matrix multiplication and linear algebra made easy.

use zoea::mtx;
// Create a 3x1000 f32 random matrix with values between -1 and 1
// Create a 1000x4 f32 random matrix with values between 5 and 25
let a = mtx::new_f32_random(3, 1000, -1f32, 1f32); //type = mtx::DMatrix \< f32>
let b = mtx::new_f32_random(1000, 4, 5f32, 25f32); // type = mtx::DMatrix \< f32>
// multiply a and b and print the result
let c = a * b;
println!("{}", c);
// take one of the values and assign it to a float
let select_element: f32 = c[(1,3)];

key-value database persistence

The Zoea kv_database (key-value) uses a sqlite backend for simple operations.

use zoea::kv_database;
fn main() {
    let db = "MyTestDatabase"; // can be &str or &String
    let key = "Key1"; // can be &str or &String
    let value = "Value you want to insert"; // can be &str or &String

    // SET the value of key in database db
    kv_database::set(&db, &key, &value);
    // GET the value of key in database db
    let same_value = kv_database::get(&db, &key);
    println!("returned value = {}", same_value);
    // LIST keys in database db
    let keys = kv_database::list_keys(&db);
    // GETting an empty key returns an empty string
    let non_key = "KeyThatDoesNotExist";
    let non_value = kv_database::get(&db, &non_key); // returns String::new();
    // DELETE a key in database db
    kv_database::delete(&db, &key);
}

Natural Language Processing (NLP)

use zoea::nlp;
fn main() {
    let sentence = String::from("Today I walked slowly to the garden in San Diego."); 
    let tokenized_bigrams = nlp::text_token_bigrams(&sentence);
    for bigram in tokenized_bigrams {
        println!("bigram= {}", bigram);
    }
}

New for v0.0.8+ : porter stems

use zoea::nlp;
let port_stems = nlp::porter_stems("Totally dude!");
assert_eq!(port_stems[0], "total");

Hashing

use zoea::hash;
fn main() {
    let mystring = String::from("Here is some string to hash"); // can be &str or &String
    let myhash = hash::hash_string(&mystring);
    println!("the hash is = {}", myhash);
}