11924200389

Committed 20 Nov 2024 12:20AM UTC coverage: 46.725% (-0.2%) from 46.956%

Build # 11924200389

Build Type

Pull #290

github

Committed by

web-flow

Commit Message

Merge faebbd075 into a6f7286de

Pull Request Pull Request #290: Fix provides within macros

Run Details

37 of 263 new or added lines in 7 files covered. (14.07%)

27 existing lines in 11 files now uncovered.

12469 of 26686 relevant lines covered (46.72%)

483326.6 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

81.25

/crates/steel-core/src/steel_vm/lazy_stream.rs

use super::vm::VmCore;
use crate::parser::span::Span;
use crate::rvals::{Result, SteelVal};
use std::cell::RefCell;
use std::rc::Rc;

use crate::values::lazy_stream::LazyStream;

// Used for inlining stream iterators
pub(crate) struct LazyStreamIter<'global, 'a> {
    stream: LazyStream,
    vm_ctx: Rc<RefCell<&'global mut VmCore<'a>>>,
    cur_inst_span: &'global Span,
}

impl<'global, 'a> LazyStreamIter<'global, 'a> {
    pub fn new(
        stream: LazyStream,
        vm_ctx: Rc<RefCell<&'global mut VmCore<'a>>>,
        cur_inst_span: &'global Span,
    ) -> Self {
        Self {
            stream,
            vm_ctx,
            cur_inst_span,
        }
    }
}

impl<'global, 'a> Iterator for LazyStreamIter<'global, 'a> {
    type Item = Result<SteelVal>;
    fn next(&mut self) -> Option<Self::Item> {
        if self.stream.empty_stream {
            return None;
        }

        let stream_first = self.stream.stream_first();
        let stream_thunk = self.stream.stream_thunk();

        let next_value = self.vm_ctx.borrow_mut().call_func_or_else_many_args(
            &stream_thunk,
            Vec::new(),
            self.cur_inst_span,
            throw!(TypeMismatch => format!("stream expected a thunk, found: {stream_thunk}")),
        );

        if let Ok(next_value) = next_value {
            if let SteelVal::StreamV(lazy_stream) = next_value {
                self.stream = lazy_stream.unwrap();
            } else {
                panic!("Lazy stream not implemented for the given type");
            }
        }

        Some(Ok(stream_first))
    }
}

#[cfg(test)]
mod stream_tests {
    use crate::steel_vm::test_util::assert_script;

    #[test]
    fn simple_stream() {
        let script = r#"
        (define (stream-cdr stream)
            ((#%stream-cdr stream)))

        (define (integers n)
            (stream-cons n (lambda () (integers (+ 1 n)))))

        (define (stream-section n stream)
            (cond ((= n 0) '())
                  (else
                   (cons
                    (stream-car stream)
                    (stream-section
                     (- n 1)
                     (stream-cdr stream))))))

        (assert! (equal? (list 0 1 2 3 4) (stream-section 5 (integers 0))))
        "#;
        assert_script(script);
    }

    #[test]
    fn simple_stream_with_map() {
        let script = r#"
        (define (stream-cdr stream)
            ((#%stream-cdr stream)))

        (define (integers n)
            (stream-cons n (lambda () (integers (+ 1 n)))))

        (define (stream-section n stream)
            (cond ((= n 0) '())
                  (else
                   (cons
                    (stream-car stream)
                    (stream-section
                     (- n 1)
                     (stream-cdr stream))))))

        (define (map-stream func s)
            (cond
                [(stream-empty? s) s]
                [else
                    (stream-cons (func (stream-car s))
                                    (lambda ()
                                    (map-stream func (stream-cdr s))))]))

        (assert! 
            (equal? (list 10 10 10 10 10)
                    (stream-section 5 (map-stream (lambda (x) 10) (integers 0)))))
        "#;
        assert_script(script);
    }

    #[test]
    fn simple_stream_with_transducer() {
        let script = r#"
        (define (stream-cdr stream)
            ((#%stream-cdr stream)))

        (define (integers n)
            (stream-cons n (lambda () (integers (+ 1 n)))))

        (assert! 
            (equal? (list 0 1 2 3 4)
                    (transduce (integers 0) (taking 5) (into-list))))
        "#;
        assert_script(script);
    }
}

1	use super::vm::VmCore;
2	use crate::parser::span::Span;
3	use crate::rvals::{Result, SteelVal};
4	use std::cell::RefCell;
5	use std::rc::Rc;
6
7	use crate::values::lazy_stream::LazyStream;
8
9	// Used for inlining stream iterators
10	pub(crate) struct LazyStreamIter<'global, 'a> {
11	stream: LazyStream,
12	vm_ctx: Rc<RefCell<&'global mut VmCore<'a>>>,
13	cur_inst_span: &'global Span,
14	}
15
16	impl<'global, 'a> LazyStreamIter<'global, 'a> {
UNCOV 17	pub fn new(	×
18	stream: LazyStream,
19	vm_ctx: Rc<RefCell<&'global mut VmCore<'a>>>,
20	cur_inst_span: &'global Span,
21	) -> Self {
22	Self {
23	stream,
24	vm_ctx,
25	cur_inst_span,
26	}
27	}
28	}
29
30	impl<'global, 'a> Iterator for LazyStreamIter<'global, 'a> {
31	type Item = Result<SteelVal>;
32	fn next(&mut self) -> Option<Self::Item> {	35✔
33	if self.stream.empty_stream {	35✔
34	return None;	×
35	}
36
37	let stream_first = self.stream.stream_first();	35✔
38	let stream_thunk = self.stream.stream_thunk();	35✔
39
40	let next_value = self.vm_ctx.borrow_mut().call_func_or_else_many_args(	35✔
41	&stream_thunk,	35✔
42	Vec::new(),	35✔
43	self.cur_inst_span,	35✔
44	throw!(TypeMismatch => format!("stream expected a thunk, found: {stream_thunk}")),	35✔
45	);
46
47	if let Ok(next_value) = next_value {	35✔
48	if let SteelVal::StreamV(lazy_stream) = next_value {	70✔
49	self.stream = lazy_stream.unwrap();	35✔
50	} else {
51	panic!("Lazy stream not implemented for the given type");	×
52	}
53	}
54
55	Some(Ok(stream_first))	35✔
56	}
57	}
58
59	#[cfg(test)]
60	mod stream_tests {
61	use crate::steel_vm::test_util::assert_script;
62
63	#[test]
64	fn simple_stream() {
65	let script = r#"
66	(define (stream-cdr stream)
67	((#%stream-cdr stream)))
68
69	(define (integers n)
70	(stream-cons n (lambda () (integers (+ 1 n)))))
71
72	(define (stream-section n stream)
73	(cond ((= n 0) '())
74	(else
75	(cons
76	(stream-car stream)
77	(stream-section
78	(- n 1)
79	(stream-cdr stream))))))
80
81	(assert! (equal? (list 0 1 2 3 4) (stream-section 5 (integers 0))))
82	"#;
83	assert_script(script);
84	}
85
86	#[test]
87	fn simple_stream_with_map() {
88	let script = r#"
89	(define (stream-cdr stream)
90	((#%stream-cdr stream)))
91
92	(define (integers n)
93	(stream-cons n (lambda () (integers (+ 1 n)))))
94
95	(define (stream-section n stream)
96	(cond ((= n 0) '())
97	(else
98	(cons
99	(stream-car stream)
100	(stream-section
101	(- n 1)
102	(stream-cdr stream))))))
103
104	(define (map-stream func s)
105	(cond
106	[(stream-empty? s) s]
107	[else
108	(stream-cons (func (stream-car s))
109	(lambda ()
110	(map-stream func (stream-cdr s))))]))
111
112	(assert!
113	(equal? (list 10 10 10 10 10)
114	(stream-section 5 (map-stream (lambda (x) 10) (integers 0)))))
115	"#;
116	assert_script(script);
117	}
118
119	#[test]
120	fn simple_stream_with_transducer() {
121	let script = r#"
122	(define (stream-cdr stream)
123	((#%stream-cdr stream)))
124
125	(define (integers n)
126	(stream-cons n (lambda () (integers (+ 1 n)))))
127
128	(assert!
129	(equal? (list 0 1 2 3 4)
130	(transduce (integers 0) (taking 5) (into-list))))
131	"#;
132	assert_script(script);
133	}
134	}

mattwparas / steel / 11924200389

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous