use super::*;
pub(super) fn install(context: &mut Runtime) {
global_builtin!(context, fn keys(call, args) {
let value = *required(args, 0, "data")?;
let keys: Vec<MiraValue> = match value.kind() {
MiraValueKind::Array(_) => (0..operations::array_len(call, value)?.unwrap_or(0))
.map(|index| MiraValue::number(index as f64))
.collect(),
MiraValueKind::Record(_) => operations::iterate_record(call, value)?
.map(|entry| call.insert(entry.key(call)?.to_owned()))
.collect::<Result<Vec<_>>>()?,
MiraValueKind::Module(_) => operations::iterate_module(call, value)?
.map(|entry| call.insert(entry.key(call)?.to_owned()))
.collect::<Result<Vec<_>>>()?,
_ => {
return Err(MiraError::runtime(RuntimeErrorKind::TypeMismatch {
expected: "compound value",
actual: value.value_type(),
}));
}
};
call.insert(keys)
});
global_builtin!(context, fn values(call, args) {
let data = Data::from_value(call, *required(args, 0, "data")?)?;
match data {
Data::Array(value) => {
let values = operations::iterable_array(call, value)?;
call.insert(values)
}
Data::Record(values) => call.insert(values.into_values().collect::<Vec<_>>()),
Data::Primitive(value) => Err(MiraError::runtime(RuntimeErrorKind::TypeMismatch {
expected: "array or record",
actual: value.value_type(),
})),
}
});
global_builtin!(context, fn entries(call, args) {
let data = Data::from_value(call, *required(args, 0, "data")?)?;
let mut entries = Vec::new();
match data {
Data::Array(value) => {
let iter = operations::iterate_array(call, value)?;
entries.reserve(iter.len());
for entry in iter {
let index = entry.index();
let value = entry.get(call)?;
entries.push(pair(call, MiraValue::number(index as f64), value)?);
}
}
Data::Record(values) => {
for (key, value) in values {
let key = call.insert(key)?;
entries.push(pair(call, key, value)?);
}
}
Data::Primitive(value) => {
return Err(MiraError::runtime(RuntimeErrorKind::TypeMismatch {
expected: "array or record",
actual: value.value_type(),
}));
}
}
call.insert(entries)
});
}