diff --git a/tests/test_lib_append.rs b/tests/test_lib_append.rs
new file mode 100644
index 0000000..a9f8383
--- /dev/null
+++ b/tests/test_lib_append.rs
@@ -0,0 +1,182 @@
+mod append_lib_tests {
+    use relish::stdlib::{get_stdlib};
+    use relish::ast::{lex, eval, ast_to_string, VTable, FTable, Ctr};
+    use std::rc::Rc;
+    use std::cell::RefCell;
+
+    #[test]
+    fn test_append_to_empty_list() {
+        let document = "(append () 1 2 3)";
+        let result = "(1 2 3)";
+        let vt = Rc::new(RefCell::new(VTable::new()));
+        let ft: Rc<RefCell<FTable>>;
+        match get_stdlib() {
+            Ok(f) => ft = f,
+            Err(s) => {
+                ft = Rc::new(RefCell::new(FTable::new()));
+                println!("Couldnt get stdlib: {}!", s);
+                assert!(false)
+            }
+        }
+
+        match lex(document.to_string()) {
+            Err(s) => {
+                println!("Couldnt lex {}: {}\n", document, s);
+                assert!(false);
+            },
+
+            Ok(tree) => {
+                match eval(tree, vt.clone(), ft.clone(), false) {
+                    Err(s) => {
+                        println!("Couldnt eval {}: {}\n", document, s);
+                        assert!(false);
+                    },
+
+                    Ok(ctr) => {
+                        match ctr {
+                            Ctr::Symbol(_)  => assert!(false),
+                            Ctr::String(_)  => assert!(false),
+                            Ctr::Integer(_) => assert!(false),
+                            Ctr::Float(_)   => assert!(false),
+                            Ctr::Bool(_)    => assert!(false),
+                            Ctr::Seg(s)     => assert_eq!(ast_to_string(s), result),
+                            Ctr::None       => assert!(false)
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    #[test]
+    fn test_append_to_full_list() {
+        let document = "(append (1 2) 3)";
+        let result = "(1 2 3)";
+        let vt = Rc::new(RefCell::new(VTable::new()));
+        let ft: Rc<RefCell<FTable>>;
+        match get_stdlib() {
+            Ok(f) => ft = f,
+            Err(s) => {
+                ft = Rc::new(RefCell::new(FTable::new()));
+                println!("Couldnt get stdlib: {}!", s);
+                assert!(false)
+            }
+        }
+
+        match lex(document.to_string()) {
+            Err(s) => {
+                println!("Couldnt lex {}: {}\n", document, s);
+                assert!(false);
+            },
+
+            Ok(tree) => {
+                match eval(tree, vt.clone(), ft.clone(), false) {
+                    Err(s) => {
+                        println!("Couldnt eval {}: {}\n", document, s);
+                        assert!(false);
+                    },
+
+                    Ok(ctr) => {
+                        match ctr {
+                            Ctr::Symbol(_)  => assert!(false),
+                            Ctr::String(_)  => assert!(false),
+                            Ctr::Integer(_) => assert!(false),
+                            Ctr::Float(_)   => assert!(false),
+                            Ctr::Bool(_)    => assert!(false),
+                            Ctr::Seg(s)     => assert_eq!(ast_to_string(s), result),
+                            Ctr::None       => assert!(false)
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    #[test]
+    fn test_mono_append() {
+        let document = "(append)";
+        let result = "()";
+        let vt = Rc::new(RefCell::new(VTable::new()));
+        let ft: Rc<RefCell<FTable>>;
+        match get_stdlib() {
+            Ok(f) => ft = f,
+            Err(s) => {
+                ft = Rc::new(RefCell::new(FTable::new()));
+                println!("Couldnt get stdlib: {}!", s);
+                assert!(false)
+            }
+        }
+
+        match lex(document.to_string()) {
+            Err(s) => {
+                println!("Couldnt lex {}: {}\n", document, s);
+                assert!(false);
+            },
+
+            Ok(tree) => {
+                match eval(tree, vt.clone(), ft.clone(), false) {
+                    Err(s) => {
+                        println!("Couldnt eval {}: {}\n", document, s);
+                        assert!(false);
+                    },
+
+                    Ok(ctr) => {
+                        match ctr {
+                            Ctr::Symbol(_)  => assert!(false),
+                            Ctr::String(_)  => assert!(false),
+                            Ctr::Integer(_) => assert!(false),
+                            Ctr::Float(_)   => assert!(false),
+                            Ctr::Bool(_)    => assert!(false),
+                            Ctr::Seg(s)     => assert_eq!(ast_to_string(s), result),
+                            Ctr::None       => assert!(false)
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    #[test]
+    fn test_append_no_list() {
+        let document = "(append 'test' 1 2 3)";
+        let result = "('test' 1 2 3)";
+        let vt = Rc::new(RefCell::new(VTable::new()));
+        let ft: Rc<RefCell<FTable>>;
+        match get_stdlib() {
+            Ok(f) => ft = f,
+            Err(s) => {
+                ft = Rc::new(RefCell::new(FTable::new()));
+                println!("Couldnt get stdlib: {}!", s);
+                assert!(false)
+            }
+        }
+
+        match lex(document.to_string()) {
+            Err(s) => {
+                println!("Couldnt lex {}: {}\n", document, s);
+                assert!(false);
+            },
+
+            Ok(tree) => {
+                match eval(tree, vt.clone(), ft.clone(), false) {
+                    Err(s) => {
+                        println!("Couldnt eval {}: {}\n", document, s);
+                        assert!(false);
+                    },
+
+                    Ok(ctr) => {
+                        match ctr {
+                            Ctr::Symbol(_)  => assert!(false),
+                            Ctr::String(_)  => assert!(false),
+                            Ctr::Integer(_) => assert!(false),
+                            Ctr::Float(_)   => assert!(false),
+                            Ctr::Bool(_)    => assert!(false),
+                            Ctr::Seg(s)     => assert_eq!(ast_to_string(s), result),
+                            Ctr::None       => assert!(false)
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/tests/test_lib_funcs.rs b/tests/test_lib_funcs.rs
deleted file mode 100644
index 8eacede..0000000
--- a/tests/test_lib_funcs.rs
+++ /dev/null
@@ -1,94 +0,0 @@
-mod lib_func_tests {
-    use relish::stdlib::{get_stdlib};
-    use relish::ast::{lex, eval, VTable, FTable, Ctr};
-    use std::rc::Rc;
-    use std::cell::RefCell;
-
-    #[test]
-    fn test_simple_echo() {
-        let document = "(echo 'test')";
-        let result = "test\n";
-        let vt = Rc::new(RefCell::new(VTable::new()));
-        let ft: Rc<RefCell<FTable>>;
-        match get_stdlib() {
-            Ok(f) => ft = f,
-            Err(s) => {
-                ft = Rc::new(RefCell::new(FTable::new()));
-                println!("Couldnt get stdlib: {}!", s);
-                assert!(false)
-            }
-        }
-
-        match lex(document.to_string()) {
-            Err(s) => {
-                println!("Couldnt lex {}: {}\n", document, s);
-                assert!(false);
-            },
-
-            Ok(tree) => {
-                match eval(tree, vt.clone(), ft.clone(), false) {
-                    Err(s) => {
-                        println!("Couldnt eval {}: {}\n", document, s);
-                        assert!(false);
-                    },
-
-                    Ok(ctr) => {
-                        match ctr {
-                            Ctr::Symbol(_)  => assert!(false),
-                            Ctr::String(s)  => assert_eq!(s, result),
-                            Ctr::Integer(_) => assert!(false),
-                            Ctr::Float(_)   => assert!(false),
-                            Ctr::Bool(_)    => assert!(false),
-                            Ctr::Seg(_)     => assert!(false),
-                            Ctr::None       => assert!(false)
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-    #[test]
-    fn test_poly_echo() {
-        let document = "(echo 'test' 1 2 3)";
-        let result = "test\n1\n2\n3\n";
-        let vt = Rc::new(RefCell::new(VTable::new()));
-        let ft: Rc<RefCell<FTable>>;
-        match get_stdlib() {
-            Ok(f) => ft = f,
-            Err(s) => {
-                ft = Rc::new(RefCell::new(FTable::new()));
-                println!("Couldnt get stdlib: {}!", s);
-                assert!(false)
-            }
-        }
-
-        match lex(document.to_string()) {
-            Err(s) => {
-                println!("Couldnt lex {}: {}\n", document, s);
-                assert!(false);
-            },
-
-            Ok(tree) => {
-                match eval(tree, vt.clone(), ft.clone(), false) {
-                    Err(s) => {
-                        println!("Couldnt eval {}: {}\n", document, s);
-                        assert!(false);
-                    },
-
-                    Ok(ctr) => {
-                        match ctr {
-                            Ctr::Symbol(_)  => assert!(false),
-                            Ctr::String(s)  => assert_eq!(s, result),
-                            Ctr::Integer(_) => assert!(false),
-                            Ctr::Float(_)   => assert!(false),
-                            Ctr::Bool(_)    => assert!(false),
-                            Ctr::Seg(_)     => assert!(false),
-                            Ctr::None       => assert!(false)
-                        }
-                    }
-                }
-            }
-        }
-    }
-}
diff --git a/tests/test_lib_str.rs b/tests/test_lib_str.rs
new file mode 100644
index 0000000..984625d
--- /dev/null
+++ b/tests/test_lib_str.rs
@@ -0,0 +1,314 @@
+mod str_lib_tests {
+    use relish::stdlib::{get_stdlib};
+    use relish::ast::{lex, eval, ast_to_string, VTable, FTable, Ctr};
+    use std::rc::Rc;
+    use std::cell::RefCell;
+
+    #[test]
+    fn test_simple_echo() {
+        let document = "(echo 'test')";
+        let result = "test\n";
+        let vt = Rc::new(RefCell::new(VTable::new()));
+        let ft: Rc<RefCell<FTable>>;
+        match get_stdlib() {
+            Ok(f) => ft = f,
+            Err(s) => {
+                ft = Rc::new(RefCell::new(FTable::new()));
+                println!("Couldnt get stdlib: {}!", s);
+                assert!(false)
+            }
+        }
+
+        match lex(document.to_string()) {
+            Err(s) => {
+                println!("Couldnt lex {}: {}\n", document, s);
+                assert!(false);
+            },
+
+            Ok(tree) => {
+                match eval(tree, vt.clone(), ft.clone(), false) {
+                    Err(s) => {
+                        println!("Couldnt eval {}: {}\n", document, s);
+                        assert!(false);
+                    },
+
+                    Ok(ctr) => {
+                        match ctr {
+                            Ctr::Symbol(_)  => assert!(false),
+                            Ctr::String(s)  => assert_eq!(s, result),
+                            Ctr::Integer(_) => assert!(false),
+                            Ctr::Float(_)   => assert!(false),
+                            Ctr::Bool(_)    => assert!(false),
+                            Ctr::Seg(_)     => assert!(false),
+                            Ctr::None       => assert!(false)
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    #[test]
+    fn test_poly_echo() {
+        let document = "(echo 'test' 1 2 3)";
+        let result = "test\n1\n2\n3\n";
+        let vt = Rc::new(RefCell::new(VTable::new()));
+        let ft: Rc<RefCell<FTable>>;
+        match get_stdlib() {
+            Ok(f) => ft = f,
+            Err(s) => {
+                ft = Rc::new(RefCell::new(FTable::new()));
+                println!("Couldnt get stdlib: {}!", s);
+                assert!(false)
+            }
+        }
+
+        match lex(document.to_string()) {
+            Err(s) => {
+                println!("Couldnt lex {}: {}\n", document, s);
+                assert!(false);
+            },
+
+            Ok(tree) => {
+                match eval(tree, vt.clone(), ft.clone(), false) {
+                    Err(s) => {
+                        println!("Couldnt eval {}: {}\n", document, s);
+                        assert!(false);
+                    },
+
+                    Ok(ctr) => {
+                        match ctr {
+                            Ctr::Symbol(_)  => assert!(false),
+                            Ctr::String(s)  => assert_eq!(s, result),
+                            Ctr::Integer(_) => assert!(false),
+                            Ctr::Float(_)   => assert!(false),
+                            Ctr::Bool(_)    => assert!(false),
+                            Ctr::Seg(_)     => assert!(false),
+                            Ctr::None       => assert!(false)
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    #[test]
+    fn test_empty_echo() {
+        let document = "(echo)";
+        let result = "\n";
+        let vt = Rc::new(RefCell::new(VTable::new()));
+        let ft: Rc<RefCell<FTable>>;
+        match get_stdlib() {
+            Ok(f) => ft = f,
+            Err(s) => {
+                ft = Rc::new(RefCell::new(FTable::new()));
+                println!("Couldnt get stdlib: {}!", s);
+                assert!(false)
+            }
+        }
+
+        match lex(document.to_string()) {
+            Err(s) => {
+                println!("Couldnt lex {}: {}\n", document, s);
+                assert!(false);
+            },
+
+            Ok(tree) => {
+                match eval(tree, vt.clone(), ft.clone(), false) {
+                    Err(s) => {
+                        println!("Couldnt eval {}: {}\n", document, s);
+                        assert!(false);
+                    },
+
+                    Ok(ctr) => {
+                        match ctr {
+                            Ctr::Symbol(_)  => assert!(false),
+                            Ctr::String(s)  => assert_eq!(s, result),
+                            Ctr::Integer(_) => assert!(false),
+                            Ctr::Float(_)   => assert!(false),
+                            Ctr::Bool(_)    => assert!(false),
+                            Ctr::Seg(_)     => assert!(false),
+                            Ctr::None       => assert!(false)
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    #[test]
+    fn test_append_to_empty_list() {
+        let document = "(append () 1 2 3)";
+        let result = "(1 2 3)";
+        let vt = Rc::new(RefCell::new(VTable::new()));
+        let ft: Rc<RefCell<FTable>>;
+        match get_stdlib() {
+            Ok(f) => ft = f,
+            Err(s) => {
+                ft = Rc::new(RefCell::new(FTable::new()));
+                println!("Couldnt get stdlib: {}!", s);
+                assert!(false)
+            }
+        }
+
+        match lex(document.to_string()) {
+            Err(s) => {
+                println!("Couldnt lex {}: {}\n", document, s);
+                assert!(false);
+            },
+
+            Ok(tree) => {
+                match eval(tree, vt.clone(), ft.clone(), false) {
+                    Err(s) => {
+                        println!("Couldnt eval {}: {}\n", document, s);
+                        assert!(false);
+                    },
+
+                    Ok(ctr) => {
+                        match ctr {
+                            Ctr::Symbol(_)  => assert!(false),
+                            Ctr::String(_)  => assert!(false),
+                            Ctr::Integer(_) => assert!(false),
+                            Ctr::Float(_)   => assert!(false),
+                            Ctr::Bool(_)    => assert!(false),
+                            Ctr::Seg(s)     => assert_eq!(ast_to_string(s), result),
+                            Ctr::None       => assert!(false)
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    #[test]
+    fn test_append_to_full_list() {
+        let document = "(append (1 2) 3)";
+        let result = "(1 2 3)";
+        let vt = Rc::new(RefCell::new(VTable::new()));
+        let ft: Rc<RefCell<FTable>>;
+        match get_stdlib() {
+            Ok(f) => ft = f,
+            Err(s) => {
+                ft = Rc::new(RefCell::new(FTable::new()));
+                println!("Couldnt get stdlib: {}!", s);
+                assert!(false)
+            }
+        }
+
+        match lex(document.to_string()) {
+            Err(s) => {
+                println!("Couldnt lex {}: {}\n", document, s);
+                assert!(false);
+            },
+
+            Ok(tree) => {
+                match eval(tree, vt.clone(), ft.clone(), false) {
+                    Err(s) => {
+                        println!("Couldnt eval {}: {}\n", document, s);
+                        assert!(false);
+                    },
+
+                    Ok(ctr) => {
+                        match ctr {
+                            Ctr::Symbol(_)  => assert!(false),
+                            Ctr::String(_)  => assert!(false),
+                            Ctr::Integer(_) => assert!(false),
+                            Ctr::Float(_)   => assert!(false),
+                            Ctr::Bool(_)    => assert!(false),
+                            Ctr::Seg(s)     => assert_eq!(ast_to_string(s), result),
+                            Ctr::None       => assert!(false)
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    #[test]
+    fn test_mono_append() {
+        let document = "(append)";
+        let result = "()";
+        let vt = Rc::new(RefCell::new(VTable::new()));
+        let ft: Rc<RefCell<FTable>>;
+        match get_stdlib() {
+            Ok(f) => ft = f,
+            Err(s) => {
+                ft = Rc::new(RefCell::new(FTable::new()));
+                println!("Couldnt get stdlib: {}!", s);
+                assert!(false)
+            }
+        }
+
+        match lex(document.to_string()) {
+            Err(s) => {
+                println!("Couldnt lex {}: {}\n", document, s);
+                assert!(false);
+            },
+
+            Ok(tree) => {
+                match eval(tree, vt.clone(), ft.clone(), false) {
+                    Err(s) => {
+                        println!("Couldnt eval {}: {}\n", document, s);
+                        assert!(false);
+                    },
+
+                    Ok(ctr) => {
+                        match ctr {
+                            Ctr::Symbol(_)  => assert!(false),
+                            Ctr::String(_)  => assert!(false),
+                            Ctr::Integer(_) => assert!(false),
+                            Ctr::Float(_)   => assert!(false),
+                            Ctr::Bool(_)    => assert!(false),
+                            Ctr::Seg(s)     => assert_eq!(ast_to_string(s), result),
+                            Ctr::None       => assert!(false)
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    #[test]
+    fn test_append_no_list() {
+        let document = "(append 'test' 1 2 3)";
+        let result = "('test' 1 2 3)";
+        let vt = Rc::new(RefCell::new(VTable::new()));
+        let ft: Rc<RefCell<FTable>>;
+        match get_stdlib() {
+            Ok(f) => ft = f,
+            Err(s) => {
+                ft = Rc::new(RefCell::new(FTable::new()));
+                println!("Couldnt get stdlib: {}!", s);
+                assert!(false)
+            }
+        }
+
+        match lex(document.to_string()) {
+            Err(s) => {
+                println!("Couldnt lex {}: {}\n", document, s);
+                assert!(false);
+            },
+
+            Ok(tree) => {
+                match eval(tree, vt.clone(), ft.clone(), false) {
+                    Err(s) => {
+                        println!("Couldnt eval {}: {}\n", document, s);
+                        assert!(false);
+                    },
+
+                    Ok(ctr) => {
+                        match ctr {
+                            Ctr::Symbol(_)  => assert!(false),
+                            Ctr::String(_)  => assert!(false),
+                            Ctr::Integer(_) => assert!(false),
+                            Ctr::Float(_)   => assert!(false),
+                            Ctr::Bool(_)    => assert!(false),
+                            Ctr::Seg(s)     => assert_eq!(ast_to_string(s), result),
+                            Ctr::None       => assert!(false)
+                        }
+                    }
+                }
+            }
+        }
+    }
+}