scurry 0.5.0

A component-based object-oriented 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

use std::cell::RefCell;
use std::rc::Rc;

use crate::ast::{AstType, TypeAnnotation};
use crate::interpreter::object::*;

macro_rules! validate_args_len {
    ($args:expr, $expected:expr, $line:expr) => {
        if $args.len() != $expected {
            return Some(Err(RuntimeError::NotEnoughArgs {
                got: $args.len(),
                want: $expected,
                line: $line,
            }));
        }
    };
}

pub fn len(bound: Object, args: Vec<Object>, line: usize) -> Option<EvalResult> {
    validate_args_len!(args, 0, line);
    if let Object::String(obj) = bound {
        Some(Ok(Object::Int(obj.chars().count() as i32)))
    } else {
        None
    }
}

pub fn trim(bound: Object, args: Vec<Object>, line: usize) -> Option<EvalResult> {
    validate_args_len!(args, 0, line);
    if let Object::String(obj) = bound {
        Some(Ok(Object::String(obj.trim().to_owned())))
    } else {
        None
    }
}

pub fn starts_with(bound: Object, args: Vec<Object>, line: usize) -> Option<EvalResult> {
    validate_args_len!(args, 1, line);
    let Object::String(string) = &args[0] else {
        return Some(Err(RuntimeError::WrongArgType { name: "string".to_owned(), expected: TypeAnnotation::from_iter([AstType::String]), got: args[0].scurry_type().into(), line }));
    };
    if let Object::String(obj) = bound {
        Some(Ok(Object::Bool(obj.starts_with(string))))
    } else {
        None
    }
}

pub fn ends_with(bound: Object, args: Vec<Object>, line: usize) -> Option<EvalResult> {
    validate_args_len!(args, 1, line);
    let Object::String(string) = &args[0] else {
        return Some(Err(RuntimeError::WrongArgType { name: "string".to_owned(), expected: TypeAnnotation::from_iter([AstType::String]), got: args[0].scurry_type().into(), line }));
    };
    if let Object::String(obj) = bound {
        Some(Ok(Object::Bool(obj.ends_with(string))))
    } else {
        None
    }
}

pub fn substring(bound: Object, args: Vec<Object>, line: usize) -> Option<EvalResult> {
    validate_args_len!(args, 2, line);
    let Object::Int(start) = args[0] else {
        return Some(Err(RuntimeError::WrongArgType { name: "start".to_owned(), expected: TypeAnnotation::from_iter([AstType::Int]), got: args[0].scurry_type().into(), line }));
    };
    let Object::Int(end) = args[1] else {
        return Some(Err(RuntimeError::WrongArgType { name: "end".to_owned(), expected: TypeAnnotation::from_iter([AstType::Int]), got: args[1].scurry_type().into(), line }));
    };
    if let Object::String(obj) = bound {
        if start >= end {
            return Some(Err(RuntimeError::IndexOutOfRange {
                obj: Object::String(obj),
                index: start,
                line,
            }));
        }
        if start < 0 || end < 0 {
            return Some(Err(RuntimeError::IndexOutOfRange {
                obj: Object::String(obj),
                index: start,
                line,
            }));
        }
        Some(Ok(Object::String(
            obj.chars()
                .skip(start as usize)
                .take(end as usize)
                .collect(),
        )))
    } else {
        None
    }
}

pub fn split(bound: Object, args: Vec<Object>, line: usize) -> Option<EvalResult> {
    validate_args_len!(args, 1, line);
    let Object::String(delim) = &args[0] else {
        return Some(Err(RuntimeError::WrongArgType { name: "delim".to_owned(), expected: TypeAnnotation::from_iter([AstType::String]), got: args[0].scurry_type().into(), line }));
    };
    if let Object::String(obj) = bound {
        Some(Ok(Object::Array(Rc::new(RefCell::new(
            obj.split(delim)
                .map(|s| Object::String(s.to_owned()))
                .collect(),
        )))))
    } else {
        None
    }
}