knave 0.14.21

A Lisp programming language for humans and agents that infers types and ownership and compiles to readable Rust
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

use std::fmt;

use super::copy::CopyRules;
use super::typed::TypedBinder;

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct ParameterCopy<'n> {
    name: &'n str,
    form: CopyForm,
}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
enum CopyForm {
    Read,
    Dereference,
    Clone,
}

impl<'n> ParameterCopy<'n> {
    pub fn of(name: &'n str, param: &TypedBinder, copy: &CopyRules) -> Self {
        let form = if !copy.is_copy(param.ty.referent()) {
            CopyForm::Clone
        } else if param.annotated {
            CopyForm::Dereference
        } else {
            CopyForm::Read
        };
        Self { name, form }
    }

    pub fn name(&self) -> &'n str {
        self.name
    }
}

impl fmt::Display for ParameterCopy<'_> {
    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
        let name = self.name;
        match self.form {
            CopyForm::Read => write!(formatter, "{name}"),
            CopyForm::Dereference => write!(formatter, "(deref {name})"),
            CopyForm::Clone => write!(formatter, "(clone {name})"),
        }
    }
}