Refactor: introduce general operate commands to reduce duplicate code (#6879)

* make format filesize more flexible

* make code simpler

* finish refactor on bytes commands

* finish refactor on str commands

* fimplify code

* rename from column_paths to cell_paths

crates/nu-command/src/bytes/add.rs

@@ -1,4 +1,4 @@
-use super::{operate, BytesArgument};
+use crate::input_handler::{operate, CmdArgument};
 use nu_engine::CallExt;
 use nu_protocol::ast::Call;
 use nu_protocol::ast::CellPath;
@@ -10,12 +10,12 @@ struct Arguments {
     added_data: Vec<u8>,
     index: Option<usize>,
     end: bool,
-    column_paths: Option<Vec<CellPath>>,
+    cell_paths: Option<Vec<CellPath>>,
 }
 
-impl BytesArgument for Arguments {
-    fn take_column_paths(&mut self) -> Option<Vec<CellPath>> {
-        self.column_paths.take()
+impl CmdArgument for Arguments {
+    fn take_cell_paths(&mut self) -> Option<Vec<CellPath>> {
+        self.cell_paths.take()
     }
 }
 
@@ -62,12 +62,8 @@ impl Command for BytesAdd {
         input: PipelineData,
     ) -> Result<PipelineData, ShellError> {
         let added_data: Vec<u8> = call.req(engine_state, stack, 0)?;
-        let column_paths: Vec<CellPath> = call.rest(engine_state, stack, 1)?;
-        let column_paths = if column_paths.is_empty() {
-            None
-        } else {
-            Some(column_paths)
-        };
+        let cell_paths: Vec<CellPath> = call.rest(engine_state, stack, 1)?;
+        let cell_paths = (!cell_paths.is_empty()).then(|| cell_paths);
         let index: Option<usize> = call.get_flag(engine_state, stack, "index")?;
         let end = call.has_flag("end");
 
@@ -75,7 +71,7 @@ impl Command for BytesAdd {
             added_data,
             index,
             end,
-            column_paths,
+            cell_paths,
         };
         operate(add, arg, input, call.head, engine_state.ctrlc.clone())
     }
@@ -118,7 +114,25 @@ impl Command for BytesAdd {
     }
 }
 
-fn add(input: &[u8], args: &Arguments, span: Span) -> Value {
+fn add(val: &Value, args: &Arguments, span: Span) -> Value {
+    match val {
+        Value::Binary {
+            val,
+            span: val_span,
+        } => add_impl(val, args, *val_span),
+        other => Value::Error {
+            error: ShellError::UnsupportedInput(
+                format!(
+                    "Input's type is {}. This command only works with bytes.",
+                    other.get_type()
+                ),
+                span,
+            ),
+        },
+    }
+}
+
+fn add_impl(input: &[u8], args: &Arguments, span: Span) -> Value {
     match args.index {
         None => {
             if args.end {

crates/nu-command/src/bytes/at.rs

@@ -1,4 +1,4 @@
-use super::{operate, BytesArgument};
+use crate::input_handler::{operate, CmdArgument};
 use nu_engine::CallExt;
 use nu_protocol::ast::Call;
 use nu_protocol::ast::CellPath;
@@ -15,12 +15,12 @@ struct Arguments {
     start: isize,
     end: isize,
     arg_span: Span,
-    column_paths: Option<Vec<CellPath>>,
+    cell_paths: Option<Vec<CellPath>>,
 }
 
-impl BytesArgument for Arguments {
-    fn take_column_paths(&mut self) -> Option<Vec<CellPath>> {
-        self.column_paths.take()
+impl CmdArgument for Arguments {
+    fn take_cell_paths(&mut self) -> Option<Vec<CellPath>> {
+        self.cell_paths.take()
     }
 }
 
@@ -141,17 +141,13 @@ impl Command for BytesAt {
     ) -> Result<PipelineData, ShellError> {
         let range: Value = call.req(engine_state, stack, 0)?;
         let (start, end, arg_span) = parse_range(range, call.head)?;
-        let column_paths: Vec<CellPath> = call.rest(engine_state, stack, 1)?;
-        let column_paths = if column_paths.is_empty() {
-            None
-        } else {
-            Some(column_paths)
-        };
+        let cell_paths: Vec<CellPath> = call.rest(engine_state, stack, 1)?;
+        let cell_paths = (!cell_paths.is_empty()).then(|| cell_paths);
         let arg = Arguments {
             start,
             end,
             arg_span,
-            column_paths,
+            cell_paths,
         };
         operate(at, arg, input, call.head, engine_state.ctrlc.clone())
     }
@@ -228,7 +224,25 @@ impl Command for BytesAt {
     }
 }
 
-fn at(input: &[u8], arg: &Arguments, span: Span) -> Value {
+fn at(val: &Value, args: &Arguments, span: Span) -> Value {
+    match val {
+        Value::Binary {
+            val,
+            span: val_span,
+        } => at_impl(val, args, *val_span),
+        other => Value::Error {
+            error: ShellError::UnsupportedInput(
+                format!(
+                    "Input's type is {}. This command only works with bytes.",
+                    other.get_type()
+                ),
+                span,
+            ),
+        },
+    }
+}
+
+fn at_impl(input: &[u8], arg: &Arguments, span: Span) -> Value {
     let len: isize = input.len() as isize;
 
     let start: isize = if arg.start < 0 {

crates/nu-command/src/bytes/ends_with.rs

@@ -1,4 +1,4 @@
-use super::{operate, BytesArgument};
+use crate::input_handler::{operate, CmdArgument};
 use nu_engine::CallExt;
 use nu_protocol::ast::Call;
 use nu_protocol::ast::CellPath;
@@ -8,12 +8,12 @@ use nu_protocol::{Example, PipelineData, ShellError, Signature, Span, SyntaxShap
 
 struct Arguments {
     pattern: Vec<u8>,
-    column_paths: Option<Vec<CellPath>>,
+    cell_paths: Option<Vec<CellPath>>,
 }
 
-impl BytesArgument for Arguments {
-    fn take_column_paths(&mut self) -> Option<Vec<CellPath>> {
-        self.column_paths.take()
+impl CmdArgument for Arguments {
+    fn take_cell_paths(&mut self) -> Option<Vec<CellPath>> {
+        self.cell_paths.take()
     }
 }
 
@@ -53,15 +53,11 @@ impl Command for BytesEndsWith {
         input: PipelineData,
     ) -> Result<PipelineData, ShellError> {
         let pattern: Vec<u8> = call.req(engine_state, stack, 0)?;
-        let column_paths: Vec<CellPath> = call.rest(engine_state, stack, 1)?;
-        let column_paths = if column_paths.is_empty() {
-            None
-        } else {
-            Some(column_paths)
-        };
+        let cell_paths: Vec<CellPath> = call.rest(engine_state, stack, 1)?;
+        let cell_paths = (!cell_paths.is_empty()).then(|| cell_paths);
         let arg = Arguments {
             pattern,
-            column_paths,
+            cell_paths,
         };
         operate(ends_with, arg, input, call.head, engine_state.ctrlc.clone())
     }
@@ -96,10 +92,24 @@ impl Command for BytesEndsWith {
     }
 }
 
-fn ends_with(input: &[u8], Arguments { pattern, .. }: &Arguments, span: Span) -> Value {
-    Value::Bool {
-        val: input.ends_with(pattern),
-        span,
+fn ends_with(val: &Value, args: &Arguments, span: Span) -> Value {
+    match val {
+        Value::Binary {
+            val,
+            span: val_span,
+        } => Value::Bool {
+            val: val.ends_with(&args.pattern),
+            span: *val_span,
+        },
+        other => Value::Error {
+            error: ShellError::UnsupportedInput(
+                format!(
+                    "Input's type is {}. This command only works with bytes.",
+                    other.get_type()
+                ),
+                span,
+            ),
+        },
     }
 }
 

crates/nu-command/src/bytes/index_of.rs

@@ -1,4 +1,4 @@
-use super::{operate, BytesArgument};
+use crate::input_handler::{operate, CmdArgument};
 use nu_engine::CallExt;
 use nu_protocol::ast::{Call, CellPath};
 use nu_protocol::engine::{Command, EngineState, Stack};
@@ -10,12 +10,12 @@ struct Arguments {
     pattern: Vec<u8>,
     end: bool,
     all: bool,
-    column_paths: Option<Vec<CellPath>>,
+    cell_paths: Option<Vec<CellPath>>,
 }
 
-impl BytesArgument for Arguments {
-    fn take_column_paths(&mut self) -> Option<Vec<CellPath>> {
-        self.column_paths.take()
+impl CmdArgument for Arguments {
+    fn take_cell_paths(&mut self) -> Option<Vec<CellPath>> {
+        self.cell_paths.take()
     }
 }
 
@@ -60,17 +60,13 @@ impl Command for BytesIndexOf {
         input: PipelineData,
     ) -> Result<PipelineData, ShellError> {
         let pattern: Vec<u8> = call.req(engine_state, stack, 0)?;
-        let column_paths: Vec<CellPath> = call.rest(engine_state, stack, 1)?;
-        let column_paths = if column_paths.is_empty() {
-            None
-        } else {
-            Some(column_paths)
-        };
+        let cell_paths: Vec<CellPath> = call.rest(engine_state, stack, 1)?;
+        let cell_paths = (!cell_paths.is_empty()).then(|| cell_paths);
         let arg = Arguments {
             pattern,
             end: call.has_flag("end"),
             all: call.has_flag("all"),
-            column_paths,
+            cell_paths,
         };
         operate(index_of, arg, input, call.head, engine_state.ctrlc.clone())
     }
@@ -126,7 +122,25 @@ impl Command for BytesIndexOf {
     }
 }
 
-fn index_of(input: &[u8], arg: &Arguments, span: Span) -> Value {
+fn index_of(val: &Value, args: &Arguments, span: Span) -> Value {
+    match val {
+        Value::Binary {
+            val,
+            span: val_span,
+        } => index_of_impl(val, args, *val_span),
+        other => Value::Error {
+            error: ShellError::UnsupportedInput(
+                format!(
+                    "Input's type is {}. This command only works with bytes.",
+                    other.get_type()
+                ),
+                span,
+            ),
+        },
+    }
+}
+
+fn index_of_impl(input: &[u8], arg: &Arguments, span: Span) -> Value {
     if arg.all {
         search_all_index(input, &arg.pattern, arg.end, span)
     } else {

crates/nu-command/src/bytes/length.rs

@@ -1,4 +1,4 @@
-use super::{operate, BytesArgument};
+use crate::input_handler::{operate, CmdArgument};
 use nu_engine::CallExt;
 use nu_protocol::ast::Call;
 use nu_protocol::ast::CellPath;
@@ -10,12 +10,12 @@ use nu_protocol::{Example, PipelineData, ShellError, Signature, Span, SyntaxShap
 pub struct BytesLen;
 
 struct Arguments {
-    column_paths: Option<Vec<CellPath>>,
+    cell_paths: Option<Vec<CellPath>>,
 }
 
-impl BytesArgument for Arguments {
-    fn take_column_paths(&mut self) -> Option<Vec<CellPath>> {
-        self.column_paths.take()
+impl CmdArgument for Arguments {
+    fn take_cell_paths(&mut self) -> Option<Vec<CellPath>> {
+        self.cell_paths.take()
     }
 }
 
@@ -49,13 +49,9 @@ impl Command for BytesLen {
         call: &Call,
         input: PipelineData,
     ) -> Result<PipelineData, ShellError> {
-        let column_paths: Vec<CellPath> = call.rest(engine_state, stack, 1)?;
-        let column_paths = if column_paths.is_empty() {
-            None
-        } else {
-            Some(column_paths)
-        };
-        let arg = Arguments { column_paths };
+        let cell_paths: Vec<CellPath> = call.rest(engine_state, stack, 1)?;
+        let cell_paths = (!cell_paths.is_empty()).then(|| cell_paths);
+        let arg = Arguments { cell_paths };
         operate(length, arg, input, call.head, engine_state.ctrlc.clone())
     }
 
@@ -78,10 +74,24 @@ impl Command for BytesLen {
     }
 }
 
-fn length(input: &[u8], _arg: &Arguments, span: Span) -> Value {
-    Value::Int {
-        val: input.len() as i64,
-        span,
+fn length(val: &Value, _args: &Arguments, span: Span) -> Value {
+    match val {
+        Value::Binary {
+            val,
+            span: val_span,
+        } => Value::Int {
+            val: val.len() as i64,
+            span: *val_span,
+        },
+        other => Value::Error {
+            error: ShellError::UnsupportedInput(
+                format!(
+                    "Input's type is {}. This command only works with bytes.",
+                    other.get_type()
+                ),
+                span,
+            ),
+        },
     }
 }
 

crates/nu-command/src/bytes/mod.rs

@@ -11,11 +11,6 @@ mod replace;
 mod reverse;
 mod starts_with;
 
-use nu_protocol::ast::CellPath;
-use nu_protocol::{PipelineData, ShellError, Span, Value};
-use std::sync::atomic::AtomicBool;
-use std::sync::Arc;
-
 pub use add::BytesAdd;
 pub use at::BytesAt;
 pub use build_::BytesBuild;
@@ -28,71 +23,3 @@ pub use remove::BytesRemove;
 pub use replace::BytesReplace;
 pub use reverse::BytesReverse;
 pub use starts_with::BytesStartsWith;
-
-trait BytesArgument {
-    fn take_column_paths(&mut self) -> Option<Vec<CellPath>>;
-}
-
-/// map input pipeline data, for each elements, if it's Binary, invoke relative `cmd` with `arg`.
-fn operate<C, A>(
-    cmd: C,
-    mut arg: A,
-    input: PipelineData,
-    span: Span,
-    ctrlc: Option<Arc<AtomicBool>>,
-) -> Result<PipelineData, ShellError>
-where
-    A: BytesArgument + Send + Sync + 'static,
-    C: Fn(&[u8], &A, Span) -> Value + Send + Sync + 'static + Clone + Copy,
-{
-    match arg.take_column_paths() {
-        None => input.map(
-            move |v| match v {
-                Value::Binary {
-                    val,
-                    span: val_span,
-                } => cmd(&val, &arg, val_span),
-                other => Value::Error {
-                    error: ShellError::UnsupportedInput(
-                        format!(
-                            "Input's type is {}. This command only works with bytes.",
-                            other.get_type()
-                        ),
-                        span,
-                    ),
-                },
-            },
-            ctrlc,
-        ),
-        Some(column_paths) => {
-            let arg = Arc::new(arg);
-            input.map(
-                move |mut v| {
-                    for path in &column_paths {
-                        let opt = arg.clone();
-                        let r = v.update_cell_path(
-                            &path.members,
-                            Box::new(move |old| {
-                                match old {
-                                    Value::Binary {val, span: val_span} => cmd(val, &opt, *val_span),
-                                    other => Value::Error {
-                                    error: ShellError::UnsupportedInput(
-                                        format!(
-                                            "Input's type is {}. This command only works with bytes.",
-                                            other.get_type()
-                                        ),
-                                        span,
-                                 ),
-                            }}}),
-                        );
-                        if let Err(error) = r {
-                            return Value::Error { error };
-                        }
-                    }
-                    v
-                },
-                ctrlc,
-            )
-        }
-    }
-}

crates/nu-command/src/bytes/remove.rs

@@ -1,4 +1,4 @@
-use super::{operate, BytesArgument};
+use crate::input_handler::{operate, CmdArgument};
 use nu_engine::CallExt;
 use nu_protocol::{
     ast::{Call, CellPath},
@@ -9,13 +9,13 @@ use nu_protocol::{
 struct Arguments {
     pattern: Vec<u8>,
     end: bool,
-    column_paths: Option<Vec<CellPath>>,
+    cell_paths: Option<Vec<CellPath>>,
     all: bool,
 }
 
-impl BytesArgument for Arguments {
-    fn take_column_paths(&mut self) -> Option<Vec<CellPath>> {
-        self.column_paths.take()
+impl CmdArgument for Arguments {
+    fn take_cell_paths(&mut self) -> Option<Vec<CellPath>> {
+        self.cell_paths.take()
     }
 }
 
@@ -55,12 +55,8 @@ impl Command for BytesRemove {
         call: &Call,
         input: PipelineData,
     ) -> Result<PipelineData, ShellError> {
-        let column_paths: Vec<CellPath> = call.rest(engine_state, stack, 1)?;
-        let column_paths = if column_paths.is_empty() {
-            None
-        } else {
-            Some(column_paths)
-        };
+        let cell_paths: Vec<CellPath> = call.rest(engine_state, stack, 1)?;
+        let cell_paths = (!cell_paths.is_empty()).then(|| cell_paths);
         let pattern_to_remove = call.req::<Spanned<Vec<u8>>>(engine_state, stack, 0)?;
         if pattern_to_remove.item.is_empty() {
             return Err(ShellError::UnsupportedInput(
@@ -73,7 +69,7 @@ impl Command for BytesRemove {
         let arg = Arguments {
             pattern: pattern_to_remove,
             end: call.has_flag("end"),
-            column_paths,
+            cell_paths,
             all: call.has_flag("all"),
         };
 
@@ -135,7 +131,25 @@ impl Command for BytesRemove {
     }
 }
 
-fn remove(input: &[u8], arg: &Arguments, span: Span) -> Value {
+fn remove(val: &Value, args: &Arguments, span: Span) -> Value {
+    match val {
+        Value::Binary {
+            val,
+            span: val_span,
+        } => remove_impl(val, args, *val_span),
+        other => Value::Error {
+            error: ShellError::UnsupportedInput(
+                format!(
+                    "Input's type is {}. This command only works with bytes.",
+                    other.get_type()
+                ),
+                span,
+            ),
+        },
+    }
+}
+
+fn remove_impl(input: &[u8], arg: &Arguments, span: Span) -> Value {
     let mut result = vec![];
     let remove_all = arg.all;
     let input_len = input.len();

crates/nu-command/src/bytes/replace.rs

@@ -1,4 +1,4 @@
-use super::{operate, BytesArgument};
+use crate::input_handler::{operate, CmdArgument};
 use nu_engine::CallExt;
 use nu_protocol::{
     ast::{Call, CellPath},
@@ -9,13 +9,13 @@ use nu_protocol::{
 struct Arguments {
     find: Vec<u8>,
     replace: Vec<u8>,
-    column_paths: Option<Vec<CellPath>>,
+    cell_paths: Option<Vec<CellPath>>,
     all: bool,
 }
 
-impl BytesArgument for Arguments {
-    fn take_column_paths(&mut self) -> Option<Vec<CellPath>> {
-        self.column_paths.take()
+impl CmdArgument for Arguments {
+    fn take_cell_paths(&mut self) -> Option<Vec<CellPath>> {
+        self.cell_paths.take()
     }
 }
 
@@ -55,12 +55,8 @@ impl Command for BytesReplace {
         call: &Call,
         input: PipelineData,
     ) -> Result<PipelineData, ShellError> {
-        let column_paths: Vec<CellPath> = call.rest(engine_state, stack, 2)?;
-        let column_paths = if column_paths.is_empty() {
-            None
-        } else {
-            Some(column_paths)
-        };
+        let cell_paths: Vec<CellPath> = call.rest(engine_state, stack, 2)?;
+        let cell_paths = (!cell_paths.is_empty()).then(|| cell_paths);
         let find = call.req::<Spanned<Vec<u8>>>(engine_state, stack, 0)?;
         if find.item.is_empty() {
             return Err(ShellError::UnsupportedInput(
@@ -72,7 +68,7 @@ impl Command for BytesReplace {
         let arg = Arguments {
             find: find.item,
             replace: call.req::<Vec<u8>>(engine_state, stack, 1)?,
-            column_paths,
+            cell_paths,
             all: call.has_flag("all"),
         };
 
@@ -126,7 +122,25 @@ impl Command for BytesReplace {
     }
 }
 
-fn replace(input: &[u8], arg: &Arguments, span: Span) -> Value {
+fn replace(val: &Value, args: &Arguments, span: Span) -> Value {
+    match val {
+        Value::Binary {
+            val,
+            span: val_span,
+        } => replace_impl(val, args, *val_span),
+        other => Value::Error {
+            error: ShellError::UnsupportedInput(
+                format!(
+                    "Input's type is {}. This command only works with bytes.",
+                    other.get_type()
+                ),
+                span,
+            ),
+        },
+    }
+}
+
+fn replace_impl(input: &[u8], arg: &Arguments, span: Span) -> Value {
     let mut replaced = vec![];
     let replace_all = arg.all;
 

crates/nu-command/src/bytes/reverse.rs

@@ -1,4 +1,4 @@
-use super::{operate, BytesArgument};
+use crate::input_handler::{operate, CmdArgument};
 use nu_engine::CallExt;
 use nu_protocol::ast::Call;
 use nu_protocol::ast::CellPath;
@@ -7,12 +7,12 @@ use nu_protocol::Category;
 use nu_protocol::{Example, PipelineData, ShellError, Signature, Span, SyntaxShape, Value};
 
 struct Arguments {
-    column_paths: Option<Vec<CellPath>>,
+    cell_paths: Option<Vec<CellPath>>,
 }
 
-impl BytesArgument for Arguments {
-    fn take_column_paths(&mut self) -> Option<Vec<CellPath>> {
-        self.column_paths.take()
+impl CmdArgument for Arguments {
+    fn take_cell_paths(&mut self) -> Option<Vec<CellPath>> {
+        self.cell_paths.take()
     }
 }
 
@@ -50,13 +50,9 @@ impl Command for BytesReverse {
         call: &Call,
         input: PipelineData,
     ) -> Result<PipelineData, ShellError> {
-        let column_paths: Vec<CellPath> = call.rest(engine_state, stack, 0)?;
-        let column_paths = if column_paths.is_empty() {
-            None
-        } else {
-            Some(column_paths)
-        };
-        let arg = Arguments { column_paths };
+        let cell_paths: Vec<CellPath> = call.rest(engine_state, stack, 0)?;
+        let cell_paths = (!cell_paths.is_empty()).then(|| cell_paths);
+        let arg = Arguments { cell_paths };
         operate(reverse, arg, input, call.head, engine_state.ctrlc.clone())
     }
 
@@ -82,12 +78,28 @@ impl Command for BytesReverse {
     }
 }
 
-fn reverse(input: &[u8], _args: &Arguments, span: Span) -> Value {
-    let mut reversed_input = input.to_vec();
-    reversed_input.reverse();
-    Value::Binary {
-        val: reversed_input,
-        span,
+fn reverse(val: &Value, _args: &Arguments, span: Span) -> Value {
+    match val {
+        Value::Binary {
+            val,
+            span: val_span,
+        } => {
+            let mut reversed_input = val.to_vec();
+            reversed_input.reverse();
+            Value::Binary {
+                val: reversed_input,
+                span: *val_span,
+            }
+        }
+        other => Value::Error {
+            error: ShellError::UnsupportedInput(
+                format!(
+                    "Input's type is {}. This command only works with bytes.",
+                    other.get_type()
+                ),
+                span,
+            ),
+        },
     }
 }
 

crates/nu-command/src/bytes/starts_with.rs

@@ -1,4 +1,4 @@
-use super::{operate, BytesArgument};
+use crate::input_handler::{operate, CmdArgument};
 use nu_engine::CallExt;
 use nu_protocol::ast::Call;
 use nu_protocol::ast::CellPath;
@@ -8,12 +8,12 @@ use nu_protocol::{Example, PipelineData, ShellError, Signature, Span, SyntaxShap
 
 struct Arguments {
     pattern: Vec<u8>,
-    column_paths: Option<Vec<CellPath>>,
+    cell_paths: Option<Vec<CellPath>>,
 }
 
-impl BytesArgument for Arguments {
-    fn take_column_paths(&mut self) -> Option<Vec<CellPath>> {
-        self.column_paths.take()
+impl CmdArgument for Arguments {
+    fn take_cell_paths(&mut self) -> Option<Vec<CellPath>> {
+        self.cell_paths.take()
     }
 }
 
@@ -53,15 +53,11 @@ impl Command for BytesStartsWith {
         input: PipelineData,
     ) -> Result<PipelineData, ShellError> {
         let pattern: Vec<u8> = call.req(engine_state, stack, 0)?;
-        let column_paths: Vec<CellPath> = call.rest(engine_state, stack, 1)?;
-        let column_paths = if column_paths.is_empty() {
-            None
-        } else {
-            Some(column_paths)
-        };
+        let cell_paths: Vec<CellPath> = call.rest(engine_state, stack, 1)?;
+        let cell_paths = (!cell_paths.is_empty()).then(|| cell_paths);
         let arg = Arguments {
             pattern,
-            column_paths,
+            cell_paths,
         };
         operate(
             starts_with,
@@ -102,10 +98,24 @@ impl Command for BytesStartsWith {
     }
 }
 
-fn starts_with(input: &[u8], Arguments { pattern, .. }: &Arguments, span: Span) -> Value {
-    Value::Bool {
-        val: input.starts_with(pattern),
-        span,
+fn starts_with(val: &Value, args: &Arguments, span: Span) -> Value {
+    match val {
+        Value::Binary {
+            val,
+            span: val_span,
+        } => Value::Bool {
+            val: val.starts_with(&args.pattern),
+            span: *val_span,
+        },
+        other => Value::Error {
+            error: ShellError::UnsupportedInput(
+                format!(
+                    "Input's type is {}. This command only works with bytes.",
+                    other.get_type()
+                ),
+                span,
+            ),
+        },
     }
 }