val 0.6.0

An arbitrary precision calculator 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

use super::*;

#[derive(Debug, PartialEq, thiserror::Error)]
pub enum Error {
  #[error("division by zero")]
  DivisionByZero,
  #[error("exit requested with code {code}")]
  Exit { code: i32, span: Span },
  #[error("invalid decimal")]
  InvalidDecimal,
  #[error("{0}")]
  Message(String),
  #[error("modulo by zero")]
  ModuloByZero,
  #[error("{error}")]
  Spanned { error: Box<Self>, span: Span },
  #[error("zero cannot be raised to a negative power")]
  ZeroToNegativePower,
}

impl Error {
  pub fn new(span: impl Into<Span>, message: impl Into<String>) -> Self {
    Self::Message(message.into()).with_span(span)
  }

  #[must_use]
  pub fn report(&self) -> Option<Report<'static, Span>> {
    let span = self.span()?;

    let mut report =
      Report::build(ReportKind::Custom("error", Color::Red), span.clone())
        .with_config(ariadne::Config::new().with_index_type(IndexType::Byte))
        .with_message(self.to_string());

    report = report.with_label(
      Label::new(span.clone())
        .with_message(self.to_string())
        .with_color(Color::Red),
    );

    Some(report.finish())
  }

  #[must_use]
  pub fn span(&self) -> Option<&Span> {
    match self {
      Self::Exit { span, .. } | Self::Spanned { span, .. } => Some(span),
      _ => None,
    }
  }

  #[must_use]
  pub fn with_span(self, span: impl Into<Span>) -> Self {
    let span = span.into();

    match self {
      Self::Exit { code, .. } => Self::Exit { code, span },
      Self::Spanned { error, .. } => Self::Spanned { error, span },
      error => Self::Spanned {
        error: Box::new(error),
        span,
      },
    }
  }
}