Rename `Arguments` to `Args`

5 files changed, 39 insertions, 43 deletions

diff --git a/src/library/elements.rs b/src/library/elements.rs
index 6e71626a..75a43282 100644
--- a/src/library/elements.rs
+++ b/src/library/elements.rs
@@ -10,7 +10,7 @@ use crate::layout::{
 };
 
 /// `image`: An image.
-pub fn image(ctx: &mut EvalContext, args: &mut Arguments) -> TypResult<Value> {
+pub fn image(ctx: &mut EvalContext, args: &mut Args) -> TypResult<Value> {
     let path = args.expect::<Spanned<Str>>("path to image file")?;
     let width = args.named("width")?;
     let height = args.named("height")?;
@@ -31,7 +31,7 @@ pub fn image(ctx: &mut EvalContext, args: &mut Arguments) -> TypResult<Value> {
 }
 
 /// `rect`: A rectangle with optional content.
-pub fn rect(_: &mut EvalContext, args: &mut Arguments) -> TypResult<Value> {
+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")?;
@@ -40,7 +40,7 @@ pub fn rect(_: &mut EvalContext, args: &mut Arguments) -> TypResult<Value> {
 }
 
 /// `square`: A square with optional content.
-pub fn square(_: &mut EvalContext, args: &mut Arguments) -> TypResult<Value> {
+pub fn square(_: &mut EvalContext, args: &mut Args) -> TypResult<Value> {
     let length = args.named::<Length>("length")?.map(Linear::from);
     let width = match length {
         Some(length) => Some(length),
@@ -84,7 +84,7 @@ fn rect_impl(
 }
 
 /// `ellipse`: An ellipse with optional content.
-pub fn ellipse(_: &mut EvalContext, args: &mut Arguments) -> TypResult<Value> {
+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")?;
@@ -93,7 +93,7 @@ pub fn ellipse(_: &mut EvalContext, args: &mut Arguments) -> TypResult<Value> {
 }
 
 /// `circle`: A circle with optional content.
-pub fn circle(_: &mut EvalContext, args: &mut Arguments) -> TypResult<Value> {
+pub fn circle(_: &mut EvalContext, args: &mut Args) -> TypResult<Value> {
     let diameter = args.named("radius")?.map(|r: Length| 2.0 * Linear::from(r));
     let width = match diameter {
         None => args.named("width")?,
diff --git a/src/library/layout.rs b/src/library/layout.rs
index a62be646..8f645869 100644
--- a/src/library/layout.rs
+++ b/src/library/layout.rs
@@ -3,7 +3,7 @@ use crate::layout::{FixedNode, GridNode, PadNode, StackChild, StackNode, TrackSi
 use crate::paper::{Paper, PaperClass};
 
 /// `page`: Configure pages.
-pub fn page(ctx: &mut EvalContext, args: &mut Arguments) -> TypResult<Value> {
+pub fn page(ctx: &mut EvalContext, args: &mut Args) -> TypResult<Value> {
     let paper = match args.eat::<Spanned<Str>>() {
         Some(name) => match Paper::from_name(&name.v) {
             None => bail!(name.span, "invalid paper name"),
@@ -70,27 +70,27 @@ pub fn page(ctx: &mut EvalContext, args: &mut Arguments) -> TypResult<Value> {
 }
 
 /// `pagebreak`: Start a new page.
-pub fn pagebreak(ctx: &mut EvalContext, _: &mut Arguments) -> TypResult<Value> {
+pub fn pagebreak(ctx: &mut EvalContext, _: &mut Args) -> TypResult<Value> {
     ctx.template.pagebreak(true);
     Ok(Value::None)
 }
 
 /// `h`: Horizontal spacing.
-pub fn h(ctx: &mut EvalContext, args: &mut Arguments) -> TypResult<Value> {
+pub fn h(ctx: &mut EvalContext, args: &mut Args) -> TypResult<Value> {
     let spacing = args.expect("spacing")?;
     ctx.template.spacing(GenAxis::Inline, spacing);
     Ok(Value::None)
 }
 
 /// `v`: Vertical spacing.
-pub fn v(ctx: &mut EvalContext, args: &mut Arguments) -> TypResult<Value> {
+pub fn v(ctx: &mut EvalContext, args: &mut Args) -> TypResult<Value> {
     let spacing = args.expect("spacing")?;
     ctx.template.spacing(GenAxis::Block, spacing);
     Ok(Value::None)
 }
 
 /// `align`: Configure the alignment along the layouting axes.
-pub fn align(ctx: &mut EvalContext, args: &mut Arguments) -> TypResult<Value> {
+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>();
@@ -140,7 +140,7 @@ pub fn align(ctx: &mut EvalContext, args: &mut Arguments) -> TypResult<Value> {
 }
 
 /// `box`: Place content in a rectangular box.
-pub fn boxed(_: &mut EvalContext, args: &mut Arguments) -> TypResult<Value> {
+pub fn boxed(_: &mut EvalContext, args: &mut Args) -> TypResult<Value> {
     let width = args.named("width")?;
     let height = args.named("height")?;
     let body: Template = args.eat().unwrap_or_default();
@@ -155,7 +155,7 @@ pub fn boxed(_: &mut EvalContext, args: &mut Arguments) -> TypResult<Value> {
 }
 
 /// `block`: Place content in a block.
-pub fn block(_: &mut EvalContext, args: &mut Arguments) -> TypResult<Value> {
+pub fn block(_: &mut EvalContext, args: &mut Args) -> TypResult<Value> {
     let body: Template = args.expect("body")?;
     Ok(Value::Template(Template::from_block(move |state| {
         body.to_stack(state)
@@ -163,7 +163,7 @@ pub fn block(_: &mut EvalContext, args: &mut Arguments) -> TypResult<Value> {
 }
 
 /// `pad`: Pad content at the sides.
-pub fn pad(_: &mut EvalContext, args: &mut Arguments) -> TypResult<Value> {
+pub fn pad(_: &mut EvalContext, args: &mut Args) -> TypResult<Value> {
     let all = args.eat();
     let left = args.named("left")?;
     let top = args.named("top")?;
@@ -187,7 +187,7 @@ pub fn pad(_: &mut EvalContext, args: &mut Arguments) -> TypResult<Value> {
 }
 
 /// `stack`: Stack children along an axis.
-pub fn stack(_: &mut EvalContext, args: &mut Arguments) -> TypResult<Value> {
+pub fn stack(_: &mut EvalContext, args: &mut Args) -> TypResult<Value> {
     let dir = args.named("dir")?;
     let children: Vec<Template> = args.all().collect();
 
@@ -210,7 +210,7 @@ pub fn stack(_: &mut EvalContext, args: &mut Arguments) -> TypResult<Value> {
 }
 
 /// `grid`: Arrange children into a grid.
-pub fn grid(_: &mut EvalContext, args: &mut Arguments) -> TypResult<Value> {
+pub fn grid(_: &mut EvalContext, args: &mut Args) -> TypResult<Value> {
     let columns = args.named("columns")?.unwrap_or_default();
     let rows = args.named("rows")?.unwrap_or_default();
 
diff --git a/src/library/mod.rs b/src/library/mod.rs
index 102291cc..c42b82d6 100644
--- a/src/library/mod.rs
+++ b/src/library/mod.rs
@@ -18,7 +18,7 @@ use std::rc::Rc;
 
 use crate::color::{Color, RgbaColor};
 use crate::diag::{At, TypResult};
-use crate::eval::{Arguments, Array, EvalContext, Scope, State, Str, Template, Value};
+use crate::eval::{Args, Array, EvalContext, Scope, State, Str, Template, Value};
 use crate::font::{FontFamily, FontStretch, FontStyle, FontWeight, VerticalFontMetric};
 use crate::geom::*;
 use crate::layout::LayoutNode;
diff --git a/src/library/text.rs b/src/library/text.rs
index 2cb5ccaf..863586f6 100644
--- a/src/library/text.rs
+++ b/src/library/text.rs
@@ -3,7 +3,7 @@ use crate::layout::{Decoration, LineDecoration, LineKind, Paint};
 use super::*;
 
 /// `font`: Configure the font.
-pub fn font(ctx: &mut EvalContext, args: &mut Arguments) -> TypResult<Value> {
+pub fn font(ctx: &mut EvalContext, args: &mut Args) -> TypResult<Value> {
     let list = args.named("family")?.or_else(|| {
         let families: Vec<_> = args.all().collect();
         (!families.is_empty()).then(|| FontDef(Rc::new(families)))
@@ -111,7 +111,7 @@ castable! {
 }
 
 /// `par`: Configure paragraphs.
-pub fn par(ctx: &mut EvalContext, args: &mut Arguments) -> TypResult<Value> {
+pub fn par(ctx: &mut EvalContext, args: &mut Args) -> TypResult<Value> {
     let par_spacing = args.named("spacing")?;
     let line_spacing = args.named("leading")?;
 
@@ -133,7 +133,7 @@ pub fn par(ctx: &mut EvalContext, args: &mut Arguments) -> TypResult<Value> {
 }
 
 /// `lang`: Configure the language.
-pub fn lang(ctx: &mut EvalContext, args: &mut Arguments) -> TypResult<Value> {
+pub fn lang(ctx: &mut EvalContext, args: &mut Args) -> TypResult<Value> {
     let iso = args.eat::<Str>();
     let dir = if let Some(dir) = args.named::<Spanned<Dir>>("dir")? {
         if dir.v.axis() == SpecAxis::Horizontal {
@@ -164,25 +164,21 @@ fn lang_dir(iso: &str) -> Dir {
 }
 
 /// `strike`: Set striken-through text.
-pub fn strike(ctx: &mut EvalContext, args: &mut Arguments) -> TypResult<Value> {
+pub fn strike(ctx: &mut EvalContext, args: &mut Args) -> TypResult<Value> {
     line_impl(ctx, args, LineKind::Strikethrough)
 }
 
 /// `underline`: Set underlined text.
-pub fn underline(ctx: &mut EvalContext, args: &mut Arguments) -> TypResult<Value> {
+pub fn underline(ctx: &mut EvalContext, args: &mut Args) -> TypResult<Value> {
     line_impl(ctx, args, LineKind::Underline)
 }
 
 /// `overline`: Set text with an overline.
-pub fn overline(ctx: &mut EvalContext, args: &mut Arguments) -> TypResult<Value> {
+pub fn overline(ctx: &mut EvalContext, args: &mut Args) -> TypResult<Value> {
     line_impl(ctx, args, LineKind::Overline)
 }
 
-fn line_impl(
-    _: &mut EvalContext,
-    args: &mut Arguments,
-    kind: LineKind,
-) -> TypResult<Value> {
+fn line_impl(_: &mut EvalContext, 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 offset = args.named("offset")?;
@@ -201,7 +197,7 @@ fn line_impl(
 }
 
 /// `link`: Set a link.
-pub fn link(_: &mut EvalContext, args: &mut Arguments) -> TypResult<Value> {
+pub fn link(_: &mut EvalContext, args: &mut Args) -> TypResult<Value> {
     let url = args.expect::<Str>("url")?;
 
     let mut body = args.eat().unwrap_or_else(|| {
diff --git a/src/library/utility.rs b/src/library/utility.rs
index d757a7f9..f5fab6ee 100644
--- a/src/library/utility.rs
+++ b/src/library/utility.rs
@@ -6,18 +6,18 @@ use crate::color::{Color, RgbaColor};
 use super::*;
 
 /// `type`: The name of a value's type.
-pub fn type_(_: &mut EvalContext, args: &mut Arguments) -> TypResult<Value> {
+pub fn type_(_: &mut EvalContext, args: &mut Args) -> TypResult<Value> {
     Ok(args.expect::<Value>("value")?.type_name().into())
 }
 
 /// `repr`: The string representation of a value.
-pub fn repr(_: &mut EvalContext, args: &mut Arguments) -> TypResult<Value> {
+pub fn repr(_: &mut EvalContext, args: &mut Args) -> TypResult<Value> {
     Ok(args.expect::<Value>("value")?.repr().into())
 }
 
 /// `join`: Join a sequence of values, optionally interspersing it with another
 /// value.
-pub fn join(_: &mut EvalContext, args: &mut Arguments) -> TypResult<Value> {
+pub fn join(_: &mut EvalContext, args: &mut Args) -> TypResult<Value> {
     let span = args.span;
     let sep = args.named::<Value>("sep")?.unwrap_or(Value::None);
 
@@ -37,7 +37,7 @@ pub fn join(_: &mut EvalContext, args: &mut Arguments) -> TypResult<Value> {
 }
 
 /// `int`: Try to convert a value to a integer.
-pub fn int(_: &mut EvalContext, args: &mut Arguments) -> TypResult<Value> {
+pub fn int(_: &mut EvalContext, args: &mut Args) -> TypResult<Value> {
     let Spanned { v, span } = args.expect("value")?;
     Ok(Value::Int(match v {
         Value::Bool(v) => v as i64,
@@ -52,7 +52,7 @@ pub fn int(_: &mut EvalContext, args: &mut Arguments) -> TypResult<Value> {
 }
 
 /// `float`: Try to convert a value to a float.
-pub fn float(_: &mut EvalContext, args: &mut Arguments) -> TypResult<Value> {
+pub fn float(_: &mut EvalContext, args: &mut Args) -> TypResult<Value> {
     let Spanned { v, span } = args.expect("value")?;
     Ok(Value::Float(match v {
         Value::Int(v) => v as f64,
@@ -66,7 +66,7 @@ pub fn float(_: &mut EvalContext, args: &mut Arguments) -> TypResult<Value> {
 }
 
 /// `str`: Try to convert a value to a string.
-pub fn str(_: &mut EvalContext, args: &mut Arguments) -> TypResult<Value> {
+pub fn str(_: &mut EvalContext, args: &mut Args) -> TypResult<Value> {
     let Spanned { v, span } = args.expect("value")?;
     Ok(Value::Str(match v {
         Value::Int(v) => format_str!("{}", v),
@@ -77,7 +77,7 @@ pub fn str(_: &mut EvalContext, args: &mut Arguments) -> TypResult<Value> {
 }
 
 /// `abs`: The absolute value of a numeric value.
-pub fn abs(_: &mut EvalContext, args: &mut Arguments) -> TypResult<Value> {
+pub fn abs(_: &mut EvalContext, args: &mut Args) -> TypResult<Value> {
     let Spanned { v, span } = args.expect("numeric value")?;
     Ok(match v {
         Value::Int(v) => Value::Int(v.abs()),
@@ -92,17 +92,17 @@ pub fn abs(_: &mut EvalContext, args: &mut Arguments) -> TypResult<Value> {
 }
 
 /// `min`: The minimum of a sequence of values.
-pub fn min(_: &mut EvalContext, args: &mut Arguments) -> TypResult<Value> {
+pub fn min(_: &mut EvalContext, args: &mut Args) -> TypResult<Value> {
     minmax(args, Ordering::Less)
 }
 
 /// `max`: The maximum of a sequence of values.
-pub fn max(_: &mut EvalContext, args: &mut Arguments) -> TypResult<Value> {
+pub fn max(_: &mut EvalContext, args: &mut Args) -> TypResult<Value> {
     minmax(args, Ordering::Greater)
 }
 
 /// Find the minimum or maximum of a sequence of values.
-fn minmax(args: &mut Arguments, goal: Ordering) -> TypResult<Value> {
+fn minmax(args: &mut Args, goal: Ordering) -> TypResult<Value> {
     let mut extremum = args.expect::<Value>("value")?;
     for Spanned { v, span } in args.all::<Spanned<Value>>() {
         match v.partial_cmp(&extremum) {
@@ -123,7 +123,7 @@ fn minmax(args: &mut Arguments, goal: Ordering) -> TypResult<Value> {
 }
 
 /// `rgb`: Create an RGB(A) color.
-pub fn rgb(_: &mut EvalContext, args: &mut Arguments) -> TypResult<Value> {
+pub fn rgb(_: &mut EvalContext, args: &mut Args) -> TypResult<Value> {
     Ok(Value::Color(Color::Rgba(
         if let Some(string) = args.eat::<Spanned<Str>>() {
             match RgbaColor::from_str(&string.v) {
@@ -142,17 +142,17 @@ pub fn rgb(_: &mut EvalContext, args: &mut Arguments) -> TypResult<Value> {
 }
 
 /// `lower`: Convert a string to lowercase.
-pub fn lower(_: &mut EvalContext, args: &mut Arguments) -> TypResult<Value> {
+pub fn lower(_: &mut EvalContext, args: &mut Args) -> TypResult<Value> {
     Ok(args.expect::<Str>("string")?.to_lowercase().into())
 }
 
 /// `upper`: Convert a string to uppercase.
-pub fn upper(_: &mut EvalContext, args: &mut Arguments) -> TypResult<Value> {
+pub fn upper(_: &mut EvalContext, args: &mut Args) -> TypResult<Value> {
     Ok(args.expect::<Str>("string")?.to_uppercase().into())
 }
 
 /// `len`: The length of a string, an array or a dictionary.
-pub fn len(_: &mut EvalContext, args: &mut Arguments) -> TypResult<Value> {
+pub fn len(_: &mut EvalContext, args: &mut Args) -> TypResult<Value> {
     let Spanned { v, span } = args.expect("collection")?;
     Ok(Value::Int(match v {
         Value::Str(v) => v.len(),
@@ -163,7 +163,7 @@ pub fn len(_: &mut EvalContext, args: &mut Arguments) -> TypResult<Value> {
 }
 
 /// `sorted`: The sorted version of an array.
-pub fn sorted(_: &mut EvalContext, args: &mut Arguments) -> TypResult<Value> {
+pub fn sorted(_: &mut EvalContext, args: &mut Args) -> TypResult<Value> {
     let Spanned { v, span } = args.expect::<Spanned<Array>>("array")?;
     Ok(Value::Array(v.sorted().at(span)?))
 }