pipa-lang 1.0.0-alpha.1

A tiny template 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
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

// SPDX-FileCopyrightText: Copyright 2026 olav@occy.org
// SPDX-License-Identifier: MPL-2.0

use crate::lang::adapter::Adapter;
use crate::lang::args::eval_args;
use crate::lang::arity::Arity;
use crate::lang::arity::assert_func_arity;
use crate::lang::error::Error;
use crate::lang::eval::replace_operation;
use crate::lang::machine::Machine;
use crate::lang::node::Node;
use crate::value::Value;
use crate::value::list::List;

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(crate) enum Strategy {
    Clone,
    Mutate,
}

pub(crate) fn meta(
    adapter: &impl Adapter,
    machine: &mut Machine<'_>,
    stdin: Option<&Value>,
    node: Node,
) -> Result<Value, Error> {
    assert_func_arity(adapter, machine, stdin, &node, &Arity::minmax(1, 3))?;

    let strategy = Strategy::Mutate;
    let mut node = eval_args(adapter, machine, stdin, node)?;
    let value = node.pop().flatten().unwrap_or_default();
    let a1 = node.pop().flatten();
    let a0 = node.pop().flatten();

    match (a0, a1) {
        (Some(k), Some(s)) => meta_set(adapter, machine, value, strategy, &k.join(), Some(s)),
        (Some(k), None) => Ok(value.meta().get(&k.join()).unwrap_or_default().into()),
        (None, Some(k)) => Ok(value.meta().get(&k.join()).unwrap_or_default().into()),
        (None, None) => Ok(meta_into_keys(&value)),
    }
}

pub(crate) fn meta_facade_boolean(
    adapter: &impl Adapter,
    machine: &mut Machine<'_>,
    stdin: Option<&Value>,
    node: Node,
    strategy: Strategy,
    key: &[u8],
) -> Result<Value, Error> {
    meta_facade_unary(adapter, machine, stdin, node, strategy, key, key)
}

pub(crate) fn meta_facade_unary(
    adapter: &impl Adapter,
    machine: &mut Machine<'_>,
    stdin: Option<&Value>,
    node: Node,
    strategy: Strategy,
    key: &[u8],
    set: &[u8],
) -> Result<Value, Error> {
    debug_assert!(!set.is_empty(), "{}", String::from_utf8_lossy(set));

    assert_func_arity(adapter, machine, stdin, &node, &Arity::new(1))?;

    let mut node = eval_args(adapter, machine, stdin, node)?;
    let value = node.pop().flatten().unwrap_or_default();
    let set = Value::from(set);

    meta_set(adapter, machine, value, strategy, key, Some(set))
}

pub(crate) fn meta_facade_binary(
    adapter: &impl Adapter,
    machine: &mut Machine<'_>,
    stdin: Option<&Value>,
    node: Node,
    strategy: Strategy,
    key: &[u8],
) -> Result<Value, Error> {
    assert_func_arity(adapter, machine, stdin, &node, &Arity::minmax(1, 2))?;

    let mut node = eval_args(adapter, machine, stdin, node)?;
    let value = node.pop().flatten().unwrap_or_default();
    let set = node.pop().flatten();

    meta_set(adapter, machine, value, strategy, key, set)
}

fn meta_set(
    adapter: &impl Adapter,
    machine: &mut Machine<'_>,
    value: Value,
    strategy: Strategy,
    key: &[u8],
    set: Option<Value>,
) -> Result<Value, Error> {
    let Some(set) = set else {
        return Ok(value.meta().get(key).unwrap_or_default().into());
    };

    let prev = value.clone();
    let next = value.with_meta(key, set.join());

    if strategy == Strategy::Mutate {
        if let Some(keys) = next.tracer().keys.clone() {
            replace_operation(adapter, machine, &keys, &prev, &next)?;
        }
    }

    Ok(next)
}

fn meta_into_keys(value: &Value) -> Value {
    value
        .meta()
        .clone()
        .into_keys()
        .into_iter()
        .map(Value::from)
        .collect::<List>()
        .into()
}