Crate stupid_utils

Decription

A crate that provides some simple and maybe stupid or useful tools

Example

use std::collections::HashMap;
use stupid_utils::prelude::*;

let a = HashMap::new().mutable_init(|m| {
    m.insert(1, 4.box_up());
    m.insert(
        2,
        Some(9)
            .map_value(|v| match v {
                Some(v) => v,
                None => 3,
            })
            .box_up(),
    );
    let cond = true;
    m.insert(cond.select(3, 4), select(cond, 3, 4).box_up());
});

let b = {
    let mut m = HashMap::new();
    m.insert(1, Box::new(4));
    m.insert(
        2,
        Box::new({
            let v = Some(9);
            match v {
                Some(v) => v,
                None => 3,
            }
        }),
    );
    let cond = true;
    m.insert(if cond { 3 } else { 4 }, Box::new(if cond { 3 } else { 4 }));
    m
};

assert_eq!(a, b);

Modules

arc_mutex

arc_mutex_new

box_up

currying

curry a function/closure

deferNon-disable_non_zerocost

disabled

dot_debug

dot_drop

dot_ref

extend_map_iterNon-disable_non_zerocost

find_in_vec

fn_applyfn_apply

call a function by .apply(arg)

functional_traitfunctional_trait

if_iter_remainsNon-disable_non_zerocost

instant_run

just_provide

map_value

mutable_init

mutex_lock_and_unwrap

one_or_many

option_to_result

prelude

print_on_drop

provide

rebind

rebind a ident to mut or non-mut

result_to_option

select

set_mut

short_unwrap

stack_struct

tuple_indextuple_index

index a tuple by specific types

wrap_in_whatever

Macros

curry

curry a function/closure

disable

disables a identfier

instant_run

mutable

rebind a ident to mut

nonmutable

rebind a ident to non-mut