Ecosyste.ms: Awesome

An open API service indexing awesome lists of open source software.

Awesome Lists | Featured Topics | Projects

https://github.com/danielpclark/array_tool

Array helpers for Rust's Vector and String types
https://github.com/danielpclark/array_tool

crates grapheme iterator justify rust string vector wordwrap

Last synced: about 1 month ago
JSON representation

Array helpers for Rust's Vector and String types

Awesome Lists containing this project

README 

        
# array_tool

[![Build Status](https://travis-ci.org/danielpclark/array_tool.svg?branch=master)](https://travis-ci.org/danielpclark/array_tool)

[![Build Status](https://ci.appveyor.com/api/projects/status/dffq3dwb8w220q4f/branch/master?svg=true)](https://ci.appveyor.com/project/danielpclark/array-tool/branch/master)

[![Documentation](https://img.shields.io/badge/docs-100%25-brightgreen.svg)](http://danielpclark.github.io/array_tool/index.html)

[![crates.io version](https://img.shields.io/crates/v/array_tool.svg)](https://crates.io/crates/array_tool)

[![License](https://img.shields.io/badge/license-MIT%20OR%20Apache--2.0-blue.svg)]()



Array helpers for Rust.  Some of the most common methods you would

use on Arrays made available on Vectors.  Polymorphic implementations

for handling most of your use cases.



### Installation



Add the following to your Cargo.toml file

```toml

[dependencies]

array_tool = "~1.0.3"

```



And in your rust files where you plan to use it put this at the top

```rust

extern crate array_tool;

```



And if you plan to use all of the Vector helper methods available you may do

```rust

use array_tool::vec::*;

```



This crate has helpful methods for strings as well.



## Iterator Usage



```rust

use array_tool::iter::ZipOpt;

fn zip_option(self, other: U) -> ZipOption

  where Self: Sized, U: IntoIterator;

  //  let a = vec![1];

  //  let b = vec![];

  //  a.zip_option(b).next()      // input

  //  Some((Some(1), None))       // return value

```



## Vector Usage



```rust

pub fn uniques(a: Vec, b: Vec) -> Vec>

  //  array_tool::uniques(vec![1,2,3,4,5], vec![2,5,6,7,8]) // input

  //  vec![vec![1,3,4], vec![6,7,8]]                        // return value



use array_tool::vec::Uniq;

fn uniq(&self, other: Vec) -> Vec;

  //  vec![1,2,3,4,5,6].uniq( vec![1,2,5,7,9] ) // input

  //  vec![3,4,6]                               // return value

fn uniq_via bool>(&self, other: Self, f: F) -> Self;

  //  vec![1,2,3,4,5,6].uniq_via( vec![1,2,5,7,9], |&l, r| l == r + 2 ) // input 

  //  vec![1,2,4,6]                                                     // return value

fn unique(&self) -> Vec;

  //  vec![1,2,1,3,2,3,4,5,6].unique()          // input

  //  vec![1,2,3,4,5,6]                         // return value

fn unique_via bool>(&self, f: F) -> Self;

  //  vec![1.0,2.0,1.4,3.3,2.1,3.5,4.6,5.2,6.2].

  //  unique_via( |l: &f64, r: &f64| l.floor() == r.floor() ) // input

  //  vec![1.0,2.0,3.3,4.6,5.2,6.2]                           // return value

fn is_unique(&self) -> bool;

  //  vec![1,2,1,3,4,3,4,5,6].is_unique()       // input

  //  false                                     // return value

  //  vec![1,2,3,4,5,6].is_unique()             // input

  //  true                                      // return value



use array_tool::vec::Shift;

fn unshift(&mut self, other: T);    // no return value, modifies &mut self directly

  //  let mut x = vec![1,2,3];

  //  x.unshift(0);

  //  assert_eq!(x, vec![0,1,2,3]);

fn shift(&mut self) -> Option;

  //  let mut x = vec![0,1,2,3];

  //  assert_eq!(x.shift(), Some(0));

  //  assert_eq!(x, vec![1,2,3]);



use array_tool::vec::Intersect;

fn intersect(&self, other: Vec) -> Vec;

  //  vec![1,1,3,5].intersect(vec![1,2,3]) // input

  //  vec![1,3]                            // return value

fn intersect_if bool>(&self, other: Vec, validator: F) -> Vec;

  //  vec!['a','a','c','e'].intersect_if(vec!['A','B','C'], |l, r| l.eq_ignore_ascii_case(r)) // input

  //  vec!['a','c']                                                                           // return value



use array_tool::vec::Join;

fn join(&self, joiner: &'static str) -> String;

  //  vec![1,2,3].join(",")                // input

  //  "1,2,3"                              // return value



use array_tool::vec::Times;

fn times(&self, qty: i32) -> Vec;

  //  vec![1,2,3].times(3)                 // input

  //  vec![1,2,3,1,2,3,1,2,3]              // return value



use array_tool::vec::Union;

fn union(&self, other: Vec) -> Vec;

  //  vec!["a","b","c"].union(vec!["c","d","a"])   // input

  //  vec![ "a", "b", "c", "d" ]                   // return value

```



## String Usage



```rust

use array_tool::string::ToGraphemeBytesIter;

fn grapheme_bytes_iter(&'a self) -> GraphemeBytesIter<'a>;

  //  let string = "a s—d féZ";

  //  let mut graphemes = string.grapheme_bytes_iter()

  //  graphemes.skip(3).next();            // input

  //  [226, 128, 148]                      // return value for emdash `—`



use array_tool::string::Squeeze;

fn squeeze(&self, targets: &'static str) -> String;

  //  "yellow moon".squeeze("")            // input

  //  "yelow mon"                          // return value

  //  "  now   is  the".squeeze(" ")       // input

  //  " now is the"                        // return value



use array_tool::string::Justify;

fn justify_line(&self, width: usize) -> String;

  //  "asd as df asd".justify_line(16)     // input

  //  "asd  as  df  asd"                   // return value

  //  "asd as df asd".justify_line(18)     // input

  //  "asd   as   df  asd"                 // return value



use array_tool::string::SubstMarks;

fn subst_marks(&self, marks: Vec, chr: &'static str) -> String;

  //  "asdf asdf asdf".subst_marks(vec![0,5,8], "Z") // input

  //  "Zsdf ZsdZ asdf"                               // return value



use array_tool::string::WordWrap;

fn word_wrap(&self, width: usize) -> String;

  //  "01234 67 9 BC EFG IJ".word_wrap(6)  // input

  //  "01234\n67 9\nBC\nEFG IJ"            // return value



use array_tool::string::AfterWhitespace;

fn seek_end_of_whitespace(&self, offset: usize) -> Option;

  //  "asdf           asdf asdf".seek_end_of_whitespace(6) // input

  //  Some(9)                                              // return value

  //  "asdf".seek_end_of_whitespace(3)                     // input

  //  Some(0)                                              // return value

  //  "asdf           ".seek_end_of_whitespace(6)          // input

  //  None                                                 // return_value



```



## Future plans



Expect methods to become more polymorphic over time (same method implemented

for similar & compatible types).  I plan to implement many of the methods

available for Arrays in higher languages; such as Ruby. Expect regular updates.



## License



Licensed under either of



 * Apache License, Version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or http://www.apache.org/licenses/LICENSE-2.0)

 * MIT license ([MIT-LICENSE](MIT-LICENSE) or http://opensource.org/licenses/MIT)



at your option.



### Contribution



Unless you explicitly state otherwise, any contribution intentionally submitted

for inclusion in the work by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any

additional terms or conditions.