shoogah

A crate with all sorts of syntactic sugar for Rust. Many of the items are inspired from the goodness of other languages, especially Groovy. Some operations require an expanded notion of what is true and what is false. In these cases, we make use of the AsBool trait. Any type that implements AsBool, will work with shoogah.

Easy HashMap literals with the hml! macro

Define a std::collections::HashMap via a simple literal.

    #[macro_use] extern crate shoogah;
    let my_map = hml! [
        "a": 1,
        "b": 2,
        "c": 1 + 2,
    ];

In this example, my_map is of type std::collections::HashMap<&str, i32>. To create an empty map:

    #[macro_use] extern crate shoogah;
    let mut my_map = hml![:];
    my_map.insert("a", 1);

Note that in the case of an empty map declaration like this one, only after you insert an entry will the map have its type inferred. So if you try to use the empty map before inserting any entries, you'll get a compiler error. If your use case requires the empty map, add type annotations to the left hand side like this:

    #[macro_use] extern crate shoogah;
    use std::collections::HashMap;
    let mut my_map: HashMap<&str, u8> = hml![:];

Map keys can be identifiers (variable names) or lietrals like 1 or "Hello". Map values can be any type of expression.

Compact conditional expressions with the cxp! macro

    #[macro_use] extern crate shoogah;
    let x = "";
    let username = cxp!{ (x) ? (x) : ("Bytor") }; // username assigned "Bytor"

Given how complex expressions can be, the parentheses are required.

Elvis says: "Don't Repeat Yourself"; elv! macro

    #[macro_use] extern crate shoogah;
    let x = "Cygnus";
    let username = elv!{ (x) ?: ("Bytor") }; // username remains "Cygnus"

Elvis says: "Don't Repeat Yourself... again"; ela! macro

If the assigned-to variable is the condition being tested, the Elvis assignment macro (ela!) is for you.

    #[macro_use] extern crate shoogah;
    let mut username = "";
    ela!{ username ?= "Bytor" }; // username is now "Bytor"

Simple increment and decrement with the suf! macro

    #[macro_use] extern crate shoogah;
    let mut x = 1;
    assert_eq!(2, suf!{ x++ });
    assert_eq!(1, suf!{ x-- });

Collect common field values from an Iterator with the spr! macro

    #[macro_use] extern crate shoogah;
    #[derive(Clone)]
    struct Address<'a> {
        country: &'a str,
    }

    #[derive(Clone)]
    struct Customer<'c> {
        name: &'c str,
        address: Address<'c>,
    }

   let customers = vec![
       Customer{ name: "Carlos", address: Address{ country: "Spain" }},
       Customer{ name: "Johnathan", address: Address{ country: "United Kingdom" }},
       Customer{ name: "Enzo", address: Address{ country: "Italy" }},
   ];
   let countries: Vec<_> = spr! { (customers)*.address*.country };
   assert_eq!(vec!["Spain", "United Kingdom", "Italy"], countries);

Note that the operation requires collections that implement Iterator and items that implement Clone, given they are moved out of the original. Also note that parentheses are required for the first expression, allowing for chaining and literals as the initial collection.

String interpolation with sin!

    #[macro_use] extern crate shoogah;
    // Normal string literal, no inner quotes (") allowed.
    let mut msg = sin!{ "1 + 1 = ${ 1 + 1 }" };
    assert_eq!("1 + 1 = 2", msg);
    // Raw string literal, inner quotes (") are allowed.
    msg = sin!{ r#"Hello, ${ "World!" }"# };
    assert_eq!("Hello, World!", msg);

Expressions within the ${} can be almost anything except something containing a closing brace }.

Boolean coercion with boo!

    #[macro_use] extern crate shoogah;
    let x = 1; let y = 0;
    assert_eq!(true, boo!{ x });
    assert_eq!(false, boo!{ y });

Here we make use of the rules for what's true or false from the AsBool trait.

It's all still Rust under the hood

All these macros expand into normal Rust code, so the usual syntax and type requirements will apply to variable names, literals, and expressions that you use.