knave 0.12.13

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

use super::ty::Type;
use crate::core::PrimitiveType;
use crate::reader::NumberValue;

pub struct LiteralFit;

impl LiteralFit {
    pub fn is_representable(value: &NumberValue) -> bool {
        match value {
            NumberValue::Float(float) => float.is_finite(),
            NumberValue::Integer(_) => true,
        }
    }

    pub fn fits(value: &NumberValue, candidate: &Type) -> bool {
        let Type::Primitive(primitive) = candidate else {
            return false;
        };
        match value {
            NumberValue::Float(float) => {
                primitive.is_float() && Self::is_finite_as(*float, *primitive)
            }
            NumberValue::Integer(_) if primitive.is_float() => true,
            NumberValue::Integer(integer) => primitive
                .integer_range()
                .is_some_and(|(minimum, maximum)| minimum <= *integer && *integer <= maximum),
        }
    }

    fn is_finite_as(float: f64, primitive: PrimitiveType) -> bool {
        match primitive {
            PrimitiveType::F32 => (float as f32).is_finite(),
            _ => float.is_finite(),
        }
    }
}