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

#![no_std]
#![forbid(unsafe_code)]
#![cfg_attr(
  feature = "nightly_slice_partition_dedup",
  feature(slice_partition_dedup)
)]
#![warn(clippy::missing_inline_in_public_items)]
#![warn(clippy::must_use_candidate)]
#![warn(missing_docs)]

//! Programmers can have a little vec, as a treat.
//!
//! ## What This Is
//!
//! This crate is a 100% safe code alternative to both
//! [arrayvec](https://docs.rs/arrayvec) and
//! [smallvec](https://docs.rs/smallvec).
//!
//! * Being 100% safe means that you have to have some sort of compromise
//!   compared to the versions using `unsafe`. In this case, the compromise is
//!   that the element type must implement `Default` to be usable in these vecs.
//!   For some people that's an absolute deal-breaker, and if so I understand.
//!   However, [quite a
//!   few](https://doc.rust-lang.org/std/default/trait.Default.html#implementors)
//!   types have a `Default` impl, so I think that for a lot of common cases you
//!   can use these vecs.
//! * [`ArrayVec`] is an array-backed vec-like where all slots are "live" in the
//!   Rust sense, but the structure tracks what the intended length is as you
//!   push and pop elements and so forth. If you try to grow the length past the
//!   array's capacity it'll error or panic (depending on the method used).
//!   * (Note: I am _very sorry_ that this type has the same name as the
//!     `ArrayVec` type in the `arrayvec` crate. We really couldn't think of
//!     another name for this sort of data structure. Please [contact
//!     us](https://github.com/Lokathor/tinyvec/issues) with a better name
//!     before this crate is 1.0 if you can think of one.)
//! * [`TinyVec`] is an enum that's either an "inline" `ArrayVec` or a "heap"
//!   `Vec`. If it's in array mode and you try to grow the vec beyond it's
//!   capacity it'll quietly transition into heap mode for you and then continue
//!   operation. This type is naturally behind the `alloc` feature gate.
//!
//! ## Stability Goal
//!
//! The crate is still in development, but we have some very clear goals:
//!
//! 1) The crate is 100% safe code. By this I don't mean a totally safe API, I
//!    mean no `unsafe` internals either. `#![forbid(unsafe_code)]`.
//!    * We do use `core` and `alloc` of course, which provide a safe API over
//!      `unsafe` operations. However, if you don't at least trust those crates
//!      then you've got bigger problems on your hands.
//! 2) No required dependencies.
//!    * We might of course provide optional dependencies for extra
//!      functionality (eg: `serde` compatability), but none of them will be
//!      required. I hate dependencies _even more_ than you do.
//! 3) The _intended_ API is that, as much as possible, these types are
//!    essentially a "drop-in" replacement for the standard
//!    [`Vec`](alloc::vec::Vec) type.
//!    * For `Vec` methods that are not yet Stable, they are sometimes provided
//!      via a crate feature, in which case the feature requires Nightly of
//!      course.
//!    * If `Vec` methods that are stable but which rely on an unstable library
//!      internal, that also requires a feature and a nightly compiler (sorry).
//!    * Some of the methods provided are **not** part of the `Vec` API but are
//!      none the less important methods to have. In this case, the method names
//!      are usually fairly long and perhaps even a little silly. It is the hope
//!      that this "convention" will prevent any potential name clash between
//!      our vec types and the standard `Vec` type.
//!    * That said, I'm not one of those "never 2.0" people, so if `Vec` lands
//!      some method with the same name as something we have, we'll just bite
//!      the bullet and fix it with a breaking change.

use core::{
  borrow::{Borrow, BorrowMut},
  cmp::PartialEq,
  convert::AsMut,
  default::Default,
  fmt::{
    Binary, Debug, Display, Formatter, LowerExp, LowerHex, Octal, Pointer,
    UpperExp, UpperHex,
  },
  iter::{Extend, FromIterator, IntoIterator, Iterator},
  mem::{needs_drop, replace},
  ops::{Deref, DerefMut, Index, IndexMut, RangeBounds},
  slice::SliceIndex,
};

#[cfg(feature = "alloc")]
extern crate alloc;

mod array;
pub use array::*;

mod arrayvec;
pub use arrayvec::*;

#[cfg(feature = "alloc")]
mod tinyvec;
#[cfg(feature = "alloc")]
pub use tinyvec::*;