git.delta.rocks / jrsonnet / refs/commits / 6b07ec04fd46

1#![allow(clippy::redundant_closure_call)]23use std::fmt::Display;45#[macro_export]6macro_rules! ty {7	((Array<number>)) => {{8		$crate::ComplexValType::ArrayRef(&$crate::ComplexValType::Simple($crate::ValType::Num))9	}};10	(array) => {11		$crate::ComplexValType::Simple($crate::ValType::Arr)12	};13	(boolean) => {14		$crate::ComplexValType::Simple($crate::ValType::Bool)15	};16	(null) => {17		$crate::ComplexValType::Simple($crate::ValType::Null)18	};19	(string) => {20		$crate::ComplexValType::Simple($crate::ValType::Str)21	};22	(char) => {23		$crate::ComplexValType::Char24	};25	(number) => {26		$crate::ComplexValType::Simple($crate::ValType::Num)27	};28	(BoundedNumber<($min:expr), ($max:expr)>) => {{29		$crate::ComplexValType::BoundedNumber($min, $max)30	}};31	(object) => {32		$crate::ComplexValType::Simple($crate::ValType::Obj)33	};34	(any) => {35		$crate::ComplexValType::Any36	};37	(function) => {38		$crate::ComplexValType::Simple($crate::ValType::Func)39	};40	(($($a:tt) |+)) => {{41		static CONTENTS: &'static [$crate::ComplexValType] = &[42			$(ty!($a)),+43		];44		$crate::ComplexValType::UnionRef(CONTENTS)45	}};46	(($($a:tt) &+)) => {{47		static CONTENTS: &'static [$crate::ComplexValType] = &[48			$(ty!($a)),+49		];50		$crate::ComplexValType::SumRef(CONTENTS)51	}};52}5354#[test]55fn test() {56	assert_eq!(57		ty!((Array<number>)),58		ComplexValType::ArrayRef(&ComplexValType::Simple(ValType::Num))59	);60	assert_eq!(ty!(array), ComplexValType::Simple(ValType::Arr));61	assert_eq!(ty!(any), ComplexValType::Any);62	assert_eq!(63		ty!((string | number)),64		ComplexValType::UnionRef(&[65			ComplexValType::Simple(ValType::Str),66			ComplexValType::Simple(ValType::Num)67		])68	);69	assert_eq!(70		format!("{}", ty!(((string & number) | (object & null)))),71		"string & number | object & null"72	);73	assert_eq!(format!("{}", ty!((string | array))), "string | array");74	assert_eq!(75		format!("{}", ty!(((string & number) | array))),76		"string & number | array"77	);78}7980#[derive(Debug, Clone, Copy, PartialEq, Eq)]81pub enum ValType {82	Bool,83	Null,84	Str,85	Num,86	Arr,87	Obj,88	Func,89}9091impl ValType {92	pub const fn name(&self) -> &'static str {93		use ValType::*;94		match self {95			Bool => "boolean",96			Null => "null",97			Str => "string",98			Num => "number",99			Arr => "array",100			Obj => "object",101			Func => "function",102		}103	}104}105106impl Display for ValType {107	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {108		write!(f, "{}", self.name())109	}110}111112#[derive(Debug, Clone, PartialEq)]113pub enum ComplexValType {114	Any,115	Char,116	Simple(ValType),117	BoundedNumber(Option<f64>, Option<f64>),118	Array(Box<ComplexValType>),119	ArrayRef(&'static ComplexValType),120	ObjectRef(&'static [(&'static str, ComplexValType)]),121	Union(Vec<ComplexValType>),122	UnionRef(&'static [ComplexValType]),123	Sum(Vec<ComplexValType>),124	SumRef(&'static [ComplexValType]),125}126impl From<ValType> for ComplexValType {127	fn from(s: ValType) -> Self {128		Self::Simple(s)129	}130}131132fn write_union(133	f: &mut std::fmt::Formatter<'_>,134	is_union: bool,135	union: &[ComplexValType],136) -> std::fmt::Result {137	for (i, v) in union.iter().enumerate() {138		let should_add_braces =139			matches!(v, ComplexValType::UnionRef(_) | ComplexValType::Union(_) if !is_union);140		if i != 0 {141			write!(f, " {} ", if is_union { '|' } else { '&' })?;142		}143		if should_add_braces {144			write!(f, "(")?;145		}146		write!(f, "{}", v)?;147		if should_add_braces {148			write!(f, ")")?;149		}150	}151	Ok(())152}153154fn print_array(a: &ComplexValType, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {155	if *a == ComplexValType::Any {156		write!(f, "array")?157	} else {158		write!(f, "Array<{}>", a)?159	}160	Ok(())161}162163impl Display for ComplexValType {164	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {165		match self {166			ComplexValType::Any => write!(f, "any")?,167			ComplexValType::Simple(s) => write!(f, "{}", s)?,168			ComplexValType::Char => write!(f, "char")?,169			ComplexValType::BoundedNumber(a, b) => write!(170				f,171				"BoundedNumber<{}, {}>",172				a.map(|e| e.to_string()).unwrap_or_else(|| "".into()),173				b.map(|e| e.to_string()).unwrap_or_else(|| "".into())174			)?,175			ComplexValType::ArrayRef(a) => print_array(a, f)?,176			ComplexValType::Array(a) => print_array(a, f)?,177			ComplexValType::ObjectRef(fields) => {178				write!(f, "{{")?;179				for (i, (k, v)) in fields.iter().enumerate() {180					if i != 0 {181						write!(f, ", ")?;182					}183					write!(f, "{}: {}", k, v)?;184				}185				write!(f, "}}")?;186			}187			ComplexValType::Union(v) => write_union(f, true, v)?,188			ComplexValType::UnionRef(v) => write_union(f, true, v)?,189			ComplexValType::Sum(v) => write_union(f, false, v)?,190			ComplexValType::SumRef(v) => write_union(f, false, v)?,191		};192		Ok(())193	}194}195196peg::parser! {197pub grammar parser() for str {198	rule number() -> f64199		= n:$(['0'..='9']+) { n.parse().unwrap() }200201	rule any_ty() -> ComplexValType = "any" { ComplexValType::Any }202	rule char_ty() -> ComplexValType = "character" { ComplexValType::Char }203	rule bool_ty() -> ComplexValType = "boolean" { ComplexValType::Simple(ValType::Bool) }204	rule null_ty() -> ComplexValType = "null" { ComplexValType::Simple(ValType::Null) }205	rule str_ty() -> ComplexValType = "string" { ComplexValType::Simple(ValType::Str) }206	rule num_ty() -> ComplexValType = "number" { ComplexValType::Simple(ValType::Num) }207	rule simple_array_ty() -> ComplexValType = "array" { ComplexValType::Simple(ValType::Arr) }208	rule simple_object_ty() -> ComplexValType = "object" { ComplexValType::Simple(ValType::Obj) }209	rule simple_function_ty() -> ComplexValType = "function" { ComplexValType::Simple(ValType::Func) }210211	rule array_ty() -> ComplexValType212		= "Array<" t:ty() ">" { ComplexValType::Array(Box::new(t)) }213214	rule bounded_number_ty() -> ComplexValType215		= "BoundedNumber<" a:number() ", " b:number() ">" { ComplexValType::BoundedNumber(Some(a), Some(b)) }216217	rule ty_basic() -> ComplexValType218		= any_ty()219		/ char_ty()220		/ bool_ty()221		/ null_ty()222		/ str_ty()223		/ num_ty()224		/ simple_array_ty()225		/ simple_object_ty()226		/ simple_function_ty()227		/ array_ty()228		/ bounded_number_ty()229230	pub rule ty() -> ComplexValType231		= precedence! {232			a:(@) " | " b:@ {233				match a {234					ComplexValType::Union(mut a) => {235						a.push(b);236						ComplexValType::Union(a)237					}238					_ => ComplexValType::Union(vec![a, b]),239				}240			}241			--242			a:(@) " & " b:@ {243				match a {244					ComplexValType::Sum(mut a) => {245						a.push(b);246						ComplexValType::Sum(a)247					}248					_ => ComplexValType::Sum(vec![a, b]),249				}250			}251			--252			"(" t:ty() ")" { t }253			t:ty_basic() { t }254		}255}256}257258#[cfg(test)]259pub mod tests {260	use super::parser;261262	#[test]263	fn precedence() {264		assert_eq!(265			parser::ty("(any & any) | (any | any) & any")266				.unwrap()267				.to_string(),268			"any & any | (any | any) & any"269		);270	}271272	#[test]273	fn array() {274		assert_eq!(parser::ty("Array<any>").unwrap().to_string(), "array");275		assert_eq!(276			parser::ty("Array<number>").unwrap().to_string(),277			"Array<number>"278		);279	}280	#[test]281	fn bounded_number() {282		assert_eq!(283			parser::ty("BoundedNumber<1, 2>").unwrap().to_string(),284			"BoundedNumber<1, 2>"285		);286	}287}