std_tools 0.1.4

Collection of general purpose tools for solving problems. Fundamentally extend the language without spoiling, so may be used solely or in conjunction with another module of such kind.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112

/// Internal namespace.
pub( crate ) mod private
{
  use crate::*;
  use num_traits::{ Zero }; /* xxx : consider for wtools */

  /// Convertable into RGBA.
  pub trait RgbaInterface< T >
  where
    T : Zero + fmt::Debug + Clone + Copy,
  {
    /// Convert into RGBA.
    fn into_rgba( self ) -> Rgba< T >;
  }

  // xxx : here type_constructor's derives should be used

  /// RGBA
  #[ derive( Debug, Clone ) ]
  pub struct Rgba< T = f32 >
  where
    T : Zero + fmt::Debug + Clone + Copy,
  {
    /// Red.
    pub r : T,
    /// Green.
    pub g : T,
    /// Blue.
    pub b : T,
    /// Alpha.
    pub a : T,
  }

  impl< T > Default for Rgba< T >
  where
    T : Zero + fmt::Debug + Clone + Copy,
  {
    fn default() -> Self
    {
      Self
      {
        r : Zero::zero(),
        g : Zero::zero(),
        b : Zero::zero(),
        a : Zero::zero(),
      }
    }
  }

  impl< T > RgbaInterface< T > for Rgba< T >
  where
    T : Zero + fmt::Debug + Clone + Copy,
  {
    fn into_rgba( self ) -> Rgba< T >
    {
      self
    }
  }

  impl RgbaInterface< f32 >
  for [ f32 ; 3 ]
  {
    fn into_rgba( self ) -> Rgba< f32 >
    {
      Rgba::< f32 >
      {
        r : self[ 0 ],
        g : self[ 1 ],
        b : self[ 2 ],
        a : 1.0,
      }
    }
  }

}

/// Protected namespace of the module.
pub mod protected
{
  pub use super::
  {
    orphan::*,
  };
  pub use ::rgb::*;
}

pub use protected::*;

/// Parented namespace of the module.
pub mod orphan
{
  pub use super::exposed::*;
}

/// Exposed namespace of the module.
pub mod exposed
{
  pub use super::
  {
    prelude::*,
    private::Rgba,
  };
}

/// Prelude to use essentials: `use my_module::prelude::*`.
pub mod prelude
{
  pub use super::
  {
    private::RgbaInterface,
  };
}