mod_interface_meta 0.57.0

Protocol of modularity unifying interface of a module and introducing layers.
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
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146

#![doc(html_logo_url = "https://raw.githubusercontent.com/Wandalen/wTools/master/asset/img/logo_v3_trans_square.png")]
#![doc(
  html_favicon_url = "https://raw.githubusercontent.com/Wandalen/wTools/alpha/asset/img/logo_v3_trans_square_icon_small_v2.ico"
)]
#![doc(html_root_url = "https://docs.rs/mod_interface_meta/latest/mod_interface_meta/")]
#![ cfg_attr( doc, doc = include_str!( concat!( env!( "CARGO_MANIFEST_DIR" ), "/", "readme.md" ) ) ) ]
#![ cfg_attr( not( doc ), doc = "Module interface macro support" ) ]
#![warn(dead_code)]

// /// Derives.
// layer derive;
// own use super ::derive;
// // xxx: change to remove need to write explicitly that

// xxx: change to remove need to write explicitly that
// crate ::mod_interface!
// {
//   /// Derives.
//   layer derive;
//   own use super ::derive; // xxx: change to remove need to write explicitly that
// }

// xxx: clean up, ad solve problems
// - example based on simpified version of test ::layer_have_layer with single sublayer
// - example with attribute `#![ debug ]`

// xxx: write good description and the main use-case

// xxx: does not work. make it working
// use super ::test :: { compiletime, helper, smoke_test };

// // xxx: eliminate need to do such things, putting itself to proper category
// exposed use super ::test ::compiletime;
// exposed use super ::test ::helper;
// exposed use super ::test ::smoke_test;

// crate ::mod_interface!
// {
//   // xxx: make it working
//   // exposed use super;
//   exposed use super ::super ::compiletime;
//   own use
//   {
//     *
// };
// }

// xxx: make use pth ::own ::path working

// xxx: put modular files into a namespace `file` maybe
// #[ cfg( feature = "enabled" ) ]
// #[ path = "." ]
// mod file
// {
//   use super :: *;
//   pub mod tokens;
//   pub mod typ;
//   pub mod item_struct;
// }

// xxx: check
//
// - does not work
// exposed use
// {
// ::former ::Former,
// ::former ::Assign,
// };
//
// - work
//
// exposed use ::former ::
// {
//   Former,
//   Assign,
// };

// xxx: inherit all entities, somehow
//
// pub mod ca;
//
// crate ::mod_interface!
// {
//   // #![ debug ]
//
//   // xxx: syntax for that, please
//   use super ::ca;
//   own use super ::ca ::own :: *;
//
//   // /// Commands aggregator library.
//   // layer ca;
// }

mod impls;
#[ allow( unused_imports ) ]
use impls::exposed::*;
mod record;

use record::exposed::*;
mod visibility;

use visibility::exposed::*;
mod use_tree;

use use_tree::exposed::*;

///
/// Protocol of modularity unifying interface of a module and introducing layers.
///
#[ cfg( feature = "enabled" ) ]
#[ proc_macro ]
pub fn mod_interface(input: proc_macro::TokenStream) -> proc_macro::TokenStream 
{
  let result = impls::mod_interface(input);
  match result 
  {
  Ok(stream) => stream.into(),
  Err(err) => err.to_compile_error().into(),
 }
}

/*

mod_interface!
{

  pub mod file1;
  pub mod file2;

  private mod micro_private;
  own mod micro_own;
  orphan mod micro_orphan;
  exposed mod micro_exposed;
  prelude mod micro_prelude;

  use prelude_file :: *;

}

   private      < protected      < orphan      < exposed      < prelude
   itself               itself             its parent       its inter-module    its inter-module
   private              public               public             public              public

micro-module < meso-module < macro-module < inter-module

*/