add list::push and list::pop

src/builtins.rs

···
     // list
     length,
     member,
+    push,
+    pop,
 }
 
 fn print(ctx: &mut Context, args: &[ast::Expr]) -> Result {
···
         .any(|item| item == &element)
         .wrap(Value::Boolean)
         .wrap(Ok)
+}
+
+fn push(ctx: &mut Context, args: &[ast::Expr]) -> Result {
+    let [lhs, rhs] = get_args::<2>(args)?;
+    let ast::Expr::Ident(ident) = lhs else {
+        return Err(Error::MalformedExpr(format!(
+            "malformed assigment, lhs: {:?}",
+            lhs
+        )));
+    };
+    let element = ctx.eval_expr(&rhs)?;
+    let variable = ctx.lookup_mut(ident)?;
+    variable.mutate(|v| match &mut v.value {
+        Value::List(l) => {
+            l.push(element);
+            Ok(Value::Unit)
+        }
+        _ => Err(Error::TypeMismatch {
+            expected: ast::Type::List,
+            got: v.ty().clone(),
+        }),
+    })
+}
+
+fn pop(ctx: &mut Context, args: &[ast::Expr]) -> Result {
+    let [lhs] = get_args::<1>(args)?;
+    let ast::Expr::Ident(ident) = lhs else {
+        return Err(Error::MalformedExpr(format!(
+            "malformed assigment, lhs: {:?}",
+            lhs
+        )));
+    };
+    let variable = ctx.lookup_mut(ident)?;
+    variable.mutate(|v| match &mut v.value {
+        Value::List(l) => l
+            .pop()
+            .ok_or_else(|| Error::ArrayOutOfBounds { idx: 0, len: 0 }),
+        _ => Err(Error::TypeMismatch {
+            expected: ast::Type::List,
+            got: v.ty().clone(),
+        }),
+    })
 }
 
 fn get_args<const N: usize>(args: &[ast::Expr]) -> std::result::Result<&[ast::Expr; N], Error> {

src/eval.rs

···
         &self.value
     }
 
-    fn ty(&self) -> &ast::Type {
+    pub(crate) fn ty(&self) -> &ast::Type {
         &self.ty
     }
 
···
             })
         }
     }
+
+    pub(crate) fn mutate(&mut self, f: impl FnOnce(&mut Self) -> Result) -> Result {
+        f(self)
+    }
 }
 
 #[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Clone)]
···
 type NodeId = usize;
 
 impl Value {
-    fn ty(&self) -> ast::Type {
+    pub(crate) fn ty(&self) -> ast::Type {
         match self {
             Self::Unit => ast::Type::Unit,
             Self::Integer(_) => ast::Type::Integer,
···
             .wrap_ok()
     }
 
-    fn lookup(&mut self, ident: &ast::Identifier) -> std::result::Result<&Variable, Error> {
+    pub(crate) fn lookup(&mut self, ident: &ast::Identifier) -> std::result::Result<&Variable, Error> {
         self.variables
             .get(ident)
             .ok_or_else(|| Error::FailedLookup(ident.to_owned()))
     }
 
-    fn lookup_mut(&mut self, ident: &ast::Identifier) -> std::result::Result<&mut Variable, Error> {
+    pub(crate) fn lookup_mut(&mut self, ident: &ast::Identifier) -> std::result::Result<&mut Variable, Error> {
         self.variables
             .get_mut(ident)
             .ok_or_else(|| Error::FailedLookup(ident.to_owned()))