knave 0.14.11

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

use super::ty::Type;
use super::unifier::Unifier;
use crate::core::ReferenceKind;

#[derive(Clone, Copy)]
pub(super) struct ReferencePeeling<'a> {
    unifier: &'a Unifier,
}

impl<'a> ReferencePeeling<'a> {
    pub(super) fn new(unifier: &'a Unifier) -> Self {
        Self { unifier }
    }

    pub(super) fn peel(&self, ty: &Type) -> (Type, Option<ReferenceKind>) {
        let mut matched = self.unifier.resolve(ty);
        let mut mode = None;
        loop {
            match matched.clone() {
                Type::Ref(_, inner) => {
                    mode.get_or_insert(ReferenceKind::Shared);
                    matched = self.unifier.resolve(&inner);
                }
                Type::Mut(_, inner) => {
                    mode.get_or_insert(ReferenceKind::Mutable);
                    matched = self.unifier.resolve(&inner);
                }
                _ => return (matched, mode),
            }
        }
    }
}