Replace `..` syntax with `range` function

5 files changed, 45 insertions, 19 deletions

diff --git a/src/library/elements.rs b/src/library/elements.rs
index 5d87d65d..cd8a6f88 100644
--- a/src/library/elements.rs
+++ b/src/library/elements.rs
@@ -30,7 +30,7 @@ pub fn rect(_: &mut EvalContext, args: &mut Args) -> TypResult<Value> {
     let width = args.named("width")?;
     let height = args.named("height")?;
     let fill = args.named("fill")?;
-    let body = args.eat();
+    let body = args.find();
     Ok(shape_impl(ShapeKind::Rect, width, height, fill, body))
 }
 
@@ -46,7 +46,7 @@ pub fn square(_: &mut EvalContext, args: &mut Args) -> TypResult<Value> {
         size => size,
     };
     let fill = args.named("fill")?;
-    let body = args.eat();
+    let body = args.find();
     Ok(shape_impl(ShapeKind::Square, width, height, fill, body))
 }
 
@@ -55,7 +55,7 @@ pub fn ellipse(_: &mut EvalContext, args: &mut Args) -> TypResult<Value> {
     let width = args.named("width")?;
     let height = args.named("height")?;
     let fill = args.named("fill")?;
-    let body = args.eat();
+    let body = args.find();
     Ok(shape_impl(ShapeKind::Ellipse, width, height, fill, body))
 }
 
@@ -71,7 +71,7 @@ pub fn circle(_: &mut EvalContext, args: &mut Args) -> TypResult<Value> {
         diameter => diameter,
     };
     let fill = args.named("fill")?;
-    let body = args.eat();
+    let body = args.find();
     Ok(shape_impl(ShapeKind::Circle, width, height, fill, body))
 }
 
diff --git a/src/library/layout.rs b/src/library/layout.rs
index d412af67..4b416156 100644
--- a/src/library/layout.rs
+++ b/src/library/layout.rs
@@ -6,7 +6,7 @@ use crate::style::{Paper, PaperClass};
 
 /// `page`: Configure pages.
 pub fn page(ctx: &mut EvalContext, args: &mut Args) -> TypResult<Value> {
-    let paper = match args.named::<Spanned<Str>>("paper")?.or_else(|| args.eat()) {
+    let paper = match args.named::<Spanned<Str>>("paper")?.or_else(|| args.find()) {
         Some(name) => match Paper::from_name(&name.v) {
             None => bail!(name.span, "invalid paper name"),
             paper => paper,
@@ -80,9 +80,9 @@ pub fn pagebreak(_: &mut EvalContext, _: &mut Args) -> TypResult<Value> {
 
 /// `align`: Configure the alignment along the layouting axes.
 pub fn align(ctx: &mut EvalContext, args: &mut Args) -> TypResult<Value> {
-    let first = args.eat::<Align>();
-    let second = args.eat::<Align>();
-    let body = args.eat::<Template>();
+    let first = args.find::<Align>();
+    let second = args.find::<Align>();
+    let body = args.find::<Template>();
 
     let mut horizontal = args.named("horizontal")?;
     let mut vertical = args.named("vertical")?;
@@ -149,7 +149,7 @@ pub fn boxed(_: &mut EvalContext, args: &mut Args) -> TypResult<Value> {
     let width = args.named("width")?;
     let height = args.named("height")?;
     let fill = args.named("fill")?;
-    let body: Template = args.eat().unwrap_or_default();
+    let body: Template = args.find().unwrap_or_default();
     Ok(Value::Template(Template::from_inline(move |style| {
         ShapeNode {
             shape: ShapeKind::Rect,
@@ -171,7 +171,7 @@ pub fn block(_: &mut EvalContext, args: &mut Args) -> TypResult<Value> {
 
 /// `pad`: Pad content at the sides.
 pub fn pad(_: &mut EvalContext, args: &mut Args) -> TypResult<Value> {
-    let all = args.eat();
+    let all = args.find();
     let left = args.named("left")?;
     let top = args.named("top")?;
     let right = args.named("right")?;
diff --git a/src/library/mod.rs b/src/library/mod.rs
index 430e260b..919f7532 100644
--- a/src/library/mod.rs
+++ b/src/library/mod.rs
@@ -66,6 +66,7 @@ pub fn new() -> Scope {
     std.def_func("abs", abs);
     std.def_func("min", min);
     std.def_func("max", max);
+    std.def_func("range", range);
     std.def_func("rgb", rgb);
     std.def_func("lower", lower);
     std.def_func("upper", upper);
diff --git a/src/library/text.rs b/src/library/text.rs
index 8c5b2547..23d74938 100644
--- a/src/library/text.rs
+++ b/src/library/text.rs
@@ -35,18 +35,18 @@ pub fn font(ctx: &mut EvalContext, args: &mut Args) -> TypResult<Value> {
         (!families.is_empty()).then(|| FontDef(Rc::new(families)))
     });
 
-    let size = args.named::<Linear>("size")?.or_else(|| args.eat());
+    let size = args.named::<Linear>("size")?.or_else(|| args.find());
     let style = args.named("style")?;
     let weight = args.named("weight")?;
     let stretch = args.named("stretch")?;
-    let fill = args.named("fill")?.or_else(|| args.eat());
+    let fill = args.named("fill")?.or_else(|| args.find());
     let top_edge = args.named("top-edge")?;
     let bottom_edge = args.named("bottom-edge")?;
     let serif = args.named("serif")?;
     let sans_serif = args.named("sans-serif")?;
     let monospace = args.named("monospace")?;
     let fallback = args.named("fallback")?;
-    let body = args.eat::<Template>();
+    let body = args.find::<Template>();
 
     let f = move |style_: &mut Style| {
         let text = style_.text_mut();
@@ -132,7 +132,7 @@ pub fn par(ctx: &mut EvalContext, args: &mut Args) -> TypResult<Value> {
 
 /// `lang`: Configure the language.
 pub fn lang(ctx: &mut EvalContext, args: &mut Args) -> TypResult<Value> {
-    let iso = args.eat::<Str>();
+    let iso = args.find::<Str>();
     let dir = if let Some(dir) = args.named::<Spanned<Dir>>("dir")? {
         if dir.v.axis() == SpecAxis::Horizontal {
             Some(dir.v)
@@ -177,8 +177,8 @@ pub fn overline(_: &mut EvalContext, args: &mut Args) -> TypResult<Value> {
 }
 
 fn line_impl(args: &mut Args, kind: LineKind) -> TypResult<Value> {
-    let stroke = args.named("stroke")?.or_else(|| args.eat());
-    let thickness = args.named::<Linear>("thickness")?.or_else(|| args.eat());
+    let stroke = args.named("stroke")?.or_else(|| args.find());
+    let thickness = args.named::<Linear>("thickness")?.or_else(|| args.find());
     let offset = args.named("offset")?;
     let extent = args.named("extent")?.unwrap_or_default();
     let body: Template = args.expect("body")?;
@@ -197,7 +197,7 @@ fn line_impl(args: &mut Args, kind: LineKind) -> TypResult<Value> {
 /// `link`: Typeset text as a link.
 pub fn link(_: &mut EvalContext, args: &mut Args) -> TypResult<Value> {
     let url = args.expect::<Str>("url")?;
-    let body = args.eat().unwrap_or_else(|| {
+    let body = args.find().unwrap_or_else(|| {
         let mut template = Template::new();
         template.text(&url);
         template
diff --git a/src/library/utility.rs b/src/library/utility.rs
index 16a6f5db..15f2bcf5 100644
--- a/src/library/utility.rs
+++ b/src/library/utility.rs
@@ -86,7 +86,7 @@ pub fn str(_: &mut EvalContext, args: &mut Args) -> TypResult<Value> {
 /// `rgb`: Create an RGB(A) color.
 pub fn rgb(_: &mut EvalContext, args: &mut Args) -> TypResult<Value> {
     Ok(Value::Color(Color::Rgba(
-        if let Some(string) = args.eat::<Spanned<Str>>() {
+        if let Some(string) = args.find::<Spanned<Str>>() {
             match RgbaColor::from_str(&string.v) {
                 Ok(color) => color,
                 Err(_) => bail!(string.span, "invalid color"),
@@ -95,7 +95,7 @@ pub fn rgb(_: &mut EvalContext, args: &mut Args) -> TypResult<Value> {
             let r = args.expect("red component")?;
             let g = args.expect("green component")?;
             let b = args.expect("blue component")?;
-            let a = args.eat().unwrap_or(Spanned::new(1.0, Span::detached()));
+            let a = args.eat()?.unwrap_or(Spanned::new(1.0, Span::detached()));
             let f = |Spanned { v, span }: Spanned<f64>| {
                 if 0.0 <= v && v <= 1.0 {
                     Ok((v * 255.0).round() as u8)
@@ -154,6 +154,31 @@ fn minmax(args: &mut Args, goal: Ordering) -> TypResult<Value> {
     Ok(extremum)
 }
 
+/// `range`: Create a sequence of numbers.
+pub fn range(_: &mut EvalContext, args: &mut Args) -> TypResult<Value> {
+    let first = args.expect::<i64>("end")?;
+    let (start, end) = match args.eat::<i64>()? {
+        Some(second) => (first, second),
+        None => (0, first),
+    };
+
+    let step: i64 = match args.named("step")? {
+        Some(Spanned { v: 0, span }) => bail!(span, "step must not be zero"),
+        Some(Spanned { v, .. }) => v,
+        None => 1,
+    };
+
+    let mut x = start;
+    let mut seq = vec![];
+
+    while x.cmp(&end) == 0.cmp(&step) {
+        seq.push(Value::Int(x));
+        x += step;
+    }
+
+    Ok(Value::Array(Array::from_vec(seq)))
+}
+
 /// `lower`: Convert a string to lowercase.
 pub fn lower(_: &mut EvalContext, args: &mut Args) -> TypResult<Value> {
     Ok(args.expect::<Str>("string")?.to_lowercase().into())