nu-protocol 0.114.0

Nushell's internal protocols, including its abstract syntax tree
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

use std::{
    borrow::Cow,
    fmt::{self, Debug},
};

use crate::{BlockId, ShellError, Span, Value, VarId, engine::EngineState};

use serde::{Deserialize, Serialize};

#[derive(Clone, Serialize, Deserialize)]
pub struct Closure {
    pub block_id: BlockId,
    pub captures: Vec<(VarId, Value)>,
}

impl Debug for Closure {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("Closure")
            .field("block_id", &self.block_id)
            .field(
                "captures",
                &fmt::from_fn(|f| {
                    f.debug_map()
                        .entries(self.captures.iter().map(|(k, v)| (k, v)))
                        .finish()
                }),
            )
            .finish()
    }
}

impl Closure {
    pub fn coerce_into_string<'a>(
        &self,
        engine_state: &'a EngineState,
        span: Span,
    ) -> Result<Cow<'a, str>, ShellError> {
        let block = engine_state.get_block(self.block_id);
        if let Some(span) = block.span {
            let contents_bytes = engine_state.get_span_contents(span);
            Ok(String::from_utf8_lossy(contents_bytes))
        } else {
            Err(ShellError::CantConvert {
                to_type: "string".into(),
                from_type: "closure".into(),
                span,
                help: Some(format!(
                    "unable to retrieve block contents for closure with id {}",
                    self.block_id.get()
                )),
            })
        }
    }

    /// Returns an estimate of the memory size used by this Closure in bytes
    pub fn memory_size(&self) -> usize {
        std::mem::size_of::<Self>()
            + self
                .captures
                .iter()
                .map(|(_, v)| v.memory_size())
                .sum::<usize>()
    }

    pub(crate) fn compact_debug(&self) -> impl Debug {
        fmt::from_fn(|f| {
            write!(f, "{:?}: ", self.block_id)?;
            f.debug_map()
                .entries(self.captures.iter().map(|(k, v)| (k, v)))
                .finish()
        })
    }
}