Break down frame_support into smaller pieces

[juangirini]

We need to split it up into smaller crates.

This update goes hand by hand with the other changes laid out on its parent issue #133.
As part of this whole refactoring, the pallets within ./substrate/frame will be moved to ./substrate/pallets and some pieces that are now within ./substrate/frame/support will be moved up to ./substrate/frame, and probably some other bits will be moved around.
So, we need to make a decision on what's the structure that we want, for this particular issue, within ./substrate/frame.

This is a (simplified) view of how ./substrate/frame would look like if we just move out the pallets to their own folder.

frame/
├── benchmarking/
│   └── pov/
├── election-provider-support/
│   ├── benchmarking/
│   └── solution-type/
│       └── fuzzer/
├── examples/
├── executive/
├── support/
│   ├── procedural/
│   │   └── tools/
│   │       └── derive/
│   ├── src/
│   │   ├── crypto/
│   │   ├── storage/
│   │   │   ├── generator/
│   │   │   └── types/
│   │   ├── traits/
│   │   │   ├── currency/
│   │   │   ├── fungible/
│   │   │   ├── fungibles/
│   │   │   ├── imbalance/
│   │   │   ├── misc.rs
│   │   │   ├── nonfungibles.rs
│   │   │   ├── pay.rs
│   │   │   └── ...
│   │   ├── weights/
│   │   ├── dispatch_context.rs
│   │   ├── dispatch.rs
│   │   ├── genesis_builder_helper.rs
│   │   ├── hash.rs
│   │   ├── inherent.rs
│   │   ├── instances.rs
│   │   ├── migrations.rs
│   │   └── ...
│   └── test/
│       ├── compile_pass
│       └── pallet
├── system/
│   ├── benches
│   ├── benchmarking
│   └── rpc/
│       └── runtime-api
└── try-runtime
pallets/
└── ...

What I'd like to discuss in this issue is how the final structure should look like.

[juangirini]

These are some submodules that we can extract from it: dispatch, dispatch_context, crypto, hash, inherent, instances, migrations, storage, weights and also the traits.
@ggwpez @bkchr @kianenigma any feedback on this?

[bkchr]

dispatch, dispatch_context

Should stay together.

crypto, hash,

Same

inherent

Just a trait that can be moved.

instances,

Should stay.

weights

Is already its own crate.

[juangirini]

One of the main things that came to mind was if we should either organize topic-wise or kind-wise, should we end up with something like frame::dispatch::traits or frame::traits::dispatch. I prefer the former as it is more modular, but I will be happy to hear other points of view.

[juangirini]

ping @kianenigma @ggwpez @sam0x17

[sam0x17]

happy to pick this up once gav's task stuff is done. October-ish

[kianenigma]

You can scan the public API of these crates with cargo modules (or cargo public-api):

[polkadot-sdk] cargo modules generate tree -p frame-support                                                                                                                                      kiz-frame-api  ➦ ✭ ✈

crate frame_support
├── mod __private: pub
├── mod _private: pub
├── mod crypto: pub
│   └── mod ecdsa: pub
├── mod dispatch: pub
├── mod dispatch_context: pub
├── mod error: pub
├── mod genesis_builder_helper: pub
├── mod hash: pub(crate)
├── mod inherent: pub
├── mod instances: pub
├── mod migrations: pub
├── mod pallet_macros: pub
├── mod pallet_prelude: pub
├── mod storage: pub
│   ├── mod bounded_btree_map: pub
│   ├── mod bounded_btree_set: pub
│   ├── mod bounded_vec: pub
│   ├── mod child: pub
│   ├── mod generator: pub
│   │   ├── mod double_map: pub(self)
│   │   ├── mod map: pub(crate)
│   │   ├── mod nmap: pub(self)
│   │   └── mod value: pub(self)
│   ├── mod hashed: pub
│   ├── mod migration: pub
│   ├── mod private: pub(self)
│   ├── mod storage_noop_guard: pub #[cfg(any(feature = "std", feature = "runtime-benchmarks", feature = "try-runtime", test))]
│   ├── mod stream_iter: pub(self)
│   │   └── mod private: pub(self)
│   ├── mod transactional: pub
│   ├── mod types: pub
│   │   ├── mod counted_map: pub(self)
│   │   ├── mod counted_nmap: pub(self)
│   │   ├── mod double_map: pub(self)
│   │   ├── mod key: pub(self)
│   │   ├── mod map: pub(self)
│   │   ├── mod nmap: pub(self)
│   │   └── mod value: pub(self)
│   ├── mod unhashed: pub
│   └── mod weak_bounded_vec: pub
├── mod testing_prelude: pub #[cfg(feature = "std")]
├── mod traits: pub
│   ├── mod dispatch: pub(self)
│   ├── mod error: pub(self)
│   ├── mod filter: pub(self)
│   ├── mod hooks: pub(self)
│   ├── mod members: pub(self)
│   ├── mod messages: pub(self)
│   ├── mod metadata: pub(self)
│   ├── mod misc: pub(self)
│   │   └── mod defensive_prelude: pub
│   ├── mod preimages: pub(self)
│   ├── mod randomness: pub(self)
│   ├── mod safe_mode: pub(self)
│   ├── mod schedule: pub
│   │   ├── mod v1: pub
│   │   ├── mod v2: pub
│   │   └── mod v3: pub
│   ├── mod storage: pub(self)
│   ├── mod stored_map: pub(self)
│   ├── mod tokens: pub
│   │   ├── mod currency: pub
│   │   │   ├── mod lockable: pub(self)
│   │   │   └── mod reservable: pub(self)
│   │   ├── mod fungible: pub
│   │   │   ├── mod conformance_tests: pub
│   │   │   │   └── mod inspect_mutate: pub
│   │   │   ├── mod freeze: pub
│   │   │   ├── mod hold: pub
│   │   │   ├── mod imbalance: pub(self)
│   │   │   ├── mod item_of: pub(self)
│   │   │   └── mod regular: pub(self)
│   │   ├── mod fungibles: pub
│   │   │   ├── mod approvals: pub
│   │   │   ├── mod enumerable: pub(self)
│   │   │   ├── mod freeze: pub
│   │   │   ├── mod hold: pub
│   │   │   ├── mod imbalance: pub(self)
│   │   │   ├── mod lifetime: pub(self)
│   │   │   ├── mod metadata: pub
│   │   │   ├── mod regular: pub(self)
│   │   │   └── mod roles: pub
│   │   ├── mod imbalance: pub
│   │   │   ├── mod on_unbalanced: pub(self)
│   │   │   ├── mod signed_imbalance: pub(self)
│   │   │   └── mod split_two_ways: pub(self)
│   │   ├── mod misc: pub(self)
│   │   ├── mod nonfungible: pub
│   │   ├── mod nonfungible_v2: pub
│   │   ├── mod nonfungibles: pub
│   │   ├── mod nonfungibles_v2: pub
│   │   └── mod pay: pub
│   ├── mod tx_pause: pub(self)
│   ├── mod validation: pub(self)
│   └── mod voting: pub(self)
├── mod unsigned: pub
└── mod weights: pub
    ├── mod block_weights: pub(self)
    ├── mod constants: pub
    ├── mod extrinsic_weights: pub(self)
    ├── mod paritydb_weights: pub(self)
    │   └── mod constants: pub
    └── mod rocksdb_weights: pub(self)
        └── mod constants: pub