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
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
|
//! This module implements the builtins exposed in the Nix language.
//!
//! See //tvix/eval/docs/builtins.md for a some context on the
//! available builtins in Nix.
use std::{
collections::{BTreeMap, HashMap},
rc::Rc,
};
use crate::{
errors::ErrorKind,
value::{Builtin, NixAttrs, NixList, NixString, Value},
};
fn pure_builtins() -> Vec<Builtin> {
vec![
Builtin::new("abort", 1, |mut args| {
return Err(
ErrorKind::Abort(args.pop().unwrap().to_string()?.as_str().to_owned()).into(),
);
}),
Builtin::new("catAttrs", 2, |mut args| {
let list = args.pop().unwrap().to_list()?;
let key = args.pop().unwrap().to_string()?;
let mut output = vec![];
for set in list.into_iter() {
if let Some(value) = set.to_attrs()?.select(key.as_str()) {
output.push(value.clone());
}
}
Ok(Value::List(NixList::construct(output.len(), output)))
}),
Builtin::new("isAttrs", 1, |args| {
Ok(Value::Bool(matches!(args[0], Value::Attrs(_))))
}),
Builtin::new("isBool", 1, |args| {
Ok(Value::Bool(matches!(args[0], Value::Bool(_))))
}),
Builtin::new("isFloat", 1, |args| {
Ok(Value::Bool(matches!(args[0], Value::Float(_))))
}),
Builtin::new("isFunction", 1, |args| {
Ok(Value::Bool(match args[0] {
Value::Lambda(_) => true,
Value::Builtin(_) => true,
_ => false,
}))
}),
Builtin::new("isInt", 1, |args| {
Ok(Value::Bool(matches!(args[0], Value::Integer(_))))
}),
Builtin::new("isList", 1, |args| {
Ok(Value::Bool(matches!(args[0], Value::List(_))))
}),
Builtin::new("isNull", 1, |args| {
Ok(Value::Bool(matches!(args[0], Value::Null)))
}),
Builtin::new("isPath", 1, |args| {
Ok(Value::Bool(matches!(args[0], Value::Path(_))))
}),
Builtin::new("isString", 1, |args| {
Ok(Value::Bool(matches!(args[0], Value::String(_))))
}),
Builtin::new("throw", 1, |mut args| {
return Err(
ErrorKind::Throw(args.pop().unwrap().to_string()?.as_str().to_owned()).into(),
);
}),
Builtin::new("toString", 1, |args| {
// TODO: toString is actually not the same as Display
Ok(Value::String(format!("{}", args[0]).into()))
}),
Builtin::new("typeOf", 1, |args| {
Ok(Value::String(args[0].type_of().into()))
}),
]
}
fn builtins_set() -> NixAttrs {
let mut map: BTreeMap<NixString, Value> = BTreeMap::new();
for builtin in pure_builtins() {
map.insert(builtin.name().into(), Value::Builtin(builtin));
}
NixAttrs::from_map(map)
}
/// Set of Nix builtins that are globally available.
pub fn global_builtins() -> HashMap<&'static str, Value> {
let builtins = builtins_set();
let mut globals: HashMap<&'static str, Value> = HashMap::new();
// known global builtins from the builtins set.
for global in &[
"abort",
"baseNameOf",
"derivation",
"derivationStrict",
"dirOf",
"fetchGit",
"fetchMercurial",
"fetchTarball",
"fromTOML",
"import",
"isNull",
"map",
"placeholder",
"removeAttrs",
"scopedImport",
"throw",
"toString",
] {
if let Some(builtin) = builtins.select(global) {
globals.insert(global, builtin.clone());
}
}
globals.insert("builtins", Value::Attrs(Rc::new(builtins)));
globals
}
|
