hebi 0.4.0

A dynamic scripting language
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

#![allow(dead_code)]

use std::fmt::Display;

#[cfg(test)]
macro_rules! assert_snapshot {
  ($body:expr) => {
    if cfg!(feature = "__assert_snapshots") {
      insta::assert_snapshot!($body);
    } else {
      let _ = $body;
    }
  };
}

#[cfg(test)]
macro_rules! assert_debug_snapshot {
  ($body:expr) => {
    if cfg!(feature = "__assert_snapshots") {
      insta::assert_debug_snapshot!($body);
    } else {
      let _ = $body;
    }
  };
}

/* macro_rules! static_assert_size {
  ($T:ty, $S:ty) => {
    const _: fn() = || {
      let _ = ::core::mem::transmute::<$T, $S>;
    };
  };
} */

pub struct Join<Iter, Sep>(pub Iter, pub Sep);

impl<Iter, Sep> Display for Join<Iter, Sep>
where
  // TODO: get rid of this `Clone` bound by doing `peek`
  // manually
  Iter: Iterator + Clone,
  <Iter as Iterator>::Item: Display,
  Sep: Display,
{
  fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
    let sep = &self.1;
    let mut peekable = self.0.clone().peekable();
    while let Some(item) = peekable.next() {
      write!(f, "{item}")?;
      if peekable.peek().is_some() {
        write!(f, "{sep}")?;
      }
    }
    Ok(())
  }
}

pub trait JoinIter: Sized {
  fn join<Sep>(&self, sep: Sep) -> Join<Self, Sep>;
}

impl<Iter> JoinIter for Iter
where
  Iter: Sized + Iterator + Clone,
{
  fn join<Sep>(&self, sep: Sep) -> Join<Self, Sep> {
    Join(self.clone(), sep)
  }
}

pub fn num_digits(v: usize) -> usize {
  use std::iter::successors;

  successors(Some(v), |&n| (n >= 10).then_some(n / 10)).count()
}

pub trait TupleLength {
  const LENGTH: usize;
}

macro_rules! __count {
  () => (0);
  ($head:ident $($tail:ident)*) => ((1 + __count!($($tail)*)));
}

macro_rules! impl_tuple_len_for {
  ($($ty:ident),+) => {
    impl<$($ty,)+> TupleLength for ($($ty,)+) {
      const LENGTH: usize = __count!($($ty)*);
    }
  }
}

impl TupleLength for () {
  const LENGTH: usize = 0;
}

impl_tuple_len_for!(A);
impl_tuple_len_for!(A, B);
impl_tuple_len_for!(A, B, C);
impl_tuple_len_for!(A, B, C, D);
impl_tuple_len_for!(A, B, C, D, E);
impl_tuple_len_for!(A, B, C, D, E, F);
impl_tuple_len_for!(A, B, C, D, E, F, G);
impl_tuple_len_for!(A, B, C, D, E, F, G, H);
impl_tuple_len_for!(A, B, C, D, E, F, G, H, I);

pub const MAX_SAFE_INT: f64 = 9007199254740991_f64;
pub const MIN_SAFE_INT: f64 = -9007199254740991_f64;