resrap 0.17.0

A parser library.
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

use std::ops::Index;
use std::ops::Range;
use std::ops::RangeBounds;
use std::rc::Rc;
use crate::*;


/// A [Position] with length.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Span {

	position: Position,
	length: usize

}

impl Span {

	pub fn new(position: Position, length: usize) -> Span {

		Self { position, length }

	}

}

impl Span {

	pub fn position(&self) -> Position { self.position.clone() }
	
	pub fn length(&self) -> usize { self.length }
	
	pub fn slice(&self) -> &str {

		&self.position.source()[self.position.index() .. self.position.index() + self.length]

	}

	pub fn lines(&self) -> std::str::Lines<'_> {

		self.slice().lines()

	}

}

/// A [Parse] wrapper for a [Parse] value and a [Span].
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Spanned<P : Parse> {

	value: P,
	span: Span

}

impl<P : Parse> Spanned<P> {

	pub fn value(&self) -> &P { &self.value }
	pub fn span(&self) -> &Span { &self.span }

}

impl<P : Parse> Parse for Spanned<P> {

	fn parse(position: &mut Position) -> Result<Self> {
		
		let start_position = position.clone();

		let value = P::parse(position)?;

		let length = position.index();

		let span = Span {

			position: start_position,
			length

		};

		Ok(Self { value, span })

	}

}