diff --git a/src/message.rs b/src/message.rs
index d6f15eb..93427d2 100644
--- a/src/message.rs
+++ b/src/message.rs
@@ -192,7 +192,7 @@ mod msgactions {
 
     #[test]
     fn turn_document_definition_into_action() {
-        let name = Name::english(Uuid::new_v4().to_string());
+        let name = Name::english(Uuid::new_v4());
         let value = DocDef::new(name.clone());
         let result: MsgAction = value.into();
         match result {
@@ -305,8 +305,8 @@ mod messages {
     #[test]
     fn can_the_document_be_a_stringi_reference() {
         let dts = [
-            Name::english("one".to_string()),
-            Name::english("two".to_string()),
+            Name::english("one"),
+            Name::english("two"),
         ];
         for document in dts.into_iter() {
             let msg = Message::new(
@@ -342,7 +342,7 @@ mod messages {
     fn is_the_message_id_random() {
         let mut ids: Vec<Uuid> = Vec::new();
         for _ in 0..5 {
-            let msg = Message::new(Name::english("tester".to_string()), Query::new());
+            let msg = Message::new(Name::english("tester"), Query::new());
             let id = msg.get_message_id().clone();
             assert!(!ids.contains(&id), "{:?} containts  {}", ids, id);
             ids.push(id);
@@ -351,7 +351,7 @@ mod messages {
 
     #[test]
     fn Can_make_reply_message() {
-        let name = Name::english("testing".to_string());
+        let name = Name::english("testing");
         let msg = Message::new(name.clone(), MsgAction::Query(Query::new()));
         let responce = Reply::new();
         let reply = msg.response(responce);
@@ -368,7 +368,7 @@ mod messages {
 
     #[test]
     fn Can_make_error_message() {
-        let name = Name::english("testing".to_string());
+        let name = Name::english("testing");
         let msg = Message::new(name.clone(), MsgAction::Query(Query::new()));
         let err_msg = Uuid::new_v4().to_string();
         let result = msg.response(MTTError::DocumentNotFound(err_msg.clone()));
@@ -552,16 +552,16 @@ impl Name {
         &self.lang
     }
 
-    fn english(name: String) -> Self {
+    fn english<S>(name: S) -> Self where S: Into<String> {
         Self {
-            name: name,
+            name: name.into(),
             lang: Language::from_639_1("en").unwrap(),
         }
     }
 
-    fn japanese(name: String) -> Self {
+    fn japanese<S>(name: S) -> Self where S: Into<String> {
         Self {
-            name: name,
+            name: name.into(),
             lang: Language::from_639_1("ja").unwrap(),
         }
     }
@@ -640,10 +640,10 @@ impl Names {
                 if self.ids.contains_key(&data) {
                     Ok(data)
                 } else {
-                    Err(MTTError::NameNotFound(Name::english(data.to_string())))
+                    Err(MTTError::NameNotFound(Name::english(data)))
                 }
             }
-            NameType::None => Err(MTTError::NameNotFound(Name::english("none".to_string()))),
+            NameType::None => Err(MTTError::NameNotFound(Name::english("none"))),
         }
     }
 
@@ -686,7 +686,7 @@ mod names {
         let data = ["one", "two", "three", "four", "five"];
         let mut ids: HashSet<Uuid> = HashSet::new();
         for item in data.iter() {
-            let name = Name::english(item.to_string());
+            let name = Name::english(item.clone());
             ids.insert(names.add_name(name).unwrap());
         }
         assert_eq!(ids.len(), data.len());
@@ -698,7 +698,7 @@ mod names {
         let data = ["one", "two"];
         let mut ids: HashMap<Name, Uuid> = HashMap::new();
         for item in data.iter() {
-            let name = Name::english(item.to_string());
+            let name = Name::english(item.clone());
             ids.insert(name.clone(), names.add_name(name).unwrap());
         }
         for (name, id) in ids.iter() {
@@ -715,7 +715,7 @@ mod names {
     #[test]
     fn errors_on_name_not_found() {
         let mut names = Names::new();
-        let name = Name::english("missing".to_string());
+        let name = Name::english("missing");
         let result = names.get_id(&name);
         match result {
             Ok(_) => unreachable!("got {:?}, should have been error", result),
@@ -743,7 +743,7 @@ mod names {
     #[test]
     fn errors_on_missing_translation() {
         let mut names = Names::new();
-        let name = Name::english("task".to_string());
+        let name = Name::english("task");
         let lang = Language::from_639_1("ja").unwrap();
         let id = names.add_name(name).unwrap();
         let result = names.get_name(&id, &lang);
@@ -759,8 +759,8 @@ mod names {
     #[test]
     fn errors_on_duplicate_names() {
         let mut names = Names::new();
-        let data = "test".to_string();
-        let name = Name::english(data.clone());
+        let data = "test";
+        let name = Name::english(data);
         let id = names.add_name(name.clone());
         let output = names.add_name(name.clone());
         match output {
@@ -778,10 +778,10 @@ mod names {
     #[test]
     fn allows_alternate_names() {
         let mut names = Names::new();
-        let data = "test".to_string();
-        let alt = "テスト".to_string();
-        let english = Name::english(data.clone());
-        let japanese = Name::japanese(alt.clone());
+        let data = "test";
+        let alt = "テスト";
+        let english = Name::english(data);
+        let japanese = Name::japanese(alt);
         let id = names.add_name(english.clone()).unwrap();
         let result = names.add_translation(english, japanese.clone()).unwrap();
         assert_eq!(result, id);
@@ -793,10 +793,10 @@ mod names {
     #[test]
     fn errors_on_bad_translation() {
         let mut names = Names::new();
-        let data = "test".to_string();
-        let alt = "テスト".to_string();
-        let english = Name::english(data.clone());
-        let japanese = Name::japanese(alt.clone());
+        let data = "test";
+        let alt = "テスト";
+        let english = Name::english(data);
+        let japanese = Name::japanese(alt);
         let result = names.add_translation(japanese.clone(), english);
         match result {
             Ok(_) => unreachable!("got {:?}, should be invalid id error", result),
@@ -810,10 +810,10 @@ mod names {
     #[test]
     fn errors_on_translation_duplicates() {
         let mut names = Names::new();
-        let data = "test".to_string();
-        let alt = "テスト".to_string();
-        let english = Name::english(data.clone());
-        let japanese = Name::japanese(alt.clone());
+        let data = "test";
+        let alt = "テスト";
+        let english = Name::english(data);
+        let japanese = Name::japanese(alt);
         let id = names.add_name(english.clone()).unwrap();
         let id = names.add_name(japanese.clone()).unwrap();
         let result = names.add_translation(english, japanese.clone());
@@ -832,8 +832,8 @@ mod names {
     #[test]
     fn convert_path_to_route_with_ids() {
         let mut names = Names::new();
-        let data = "data".to_string();
-        let english = Name::english(data.clone());
+        let data = "data";
+        let english = Name::english(data);
         let id = names.add_name(english.clone()).unwrap();
         let msg_id = Uuid::new_v4();
         let action = Action::Query;
@@ -851,8 +851,8 @@ mod names {
     #[test]
     fn convert_path_name_to_route() {
         let mut names = Names::new();
-        let data = "data".to_string();
-        let english = Name::english(data.clone());
+        let data = "data";
+        let english = Name::english(data);
         let id = names.add_name(english.clone()).unwrap();
         let msg_id = Uuid::new_v4();
         let action = Action::Error;
@@ -926,7 +926,7 @@ mod names {
     fn convert_path_with_bad_name() {
         let mut names = Names::new();
         let msg_id = Uuid::new_v4();
-        let name = Name::english("wrong".to_string());
+        let name = Name::english("wrong");
         let action = Action::Query;
         let path = Path::new(
             Include::Some(msg_id.clone()),
@@ -1551,7 +1551,7 @@ mod routers {
     fn can_pass_message() {
         let (tx, rx) = channel();
         let router = Router::new(tx);
-        let msg = Message::new(Name::english("task".to_string()), Query::new());
+        let msg = Message::new(Name::english("task"), Query::new());
         router.send(msg.clone());
         let result = rx.recv_timeout(TIMEOUT).unwrap();
         assert_eq!(result.get_message_id(), msg.get_message_id());
@@ -1563,7 +1563,7 @@ mod routers {
         let mut router = Router::new(tx);
         let (sender, receiver) = channel();
         let id = router.add_sender(sender);
-        let msg = Message::new(Name::english("wiki".to_string()), Query::new());
+        let msg = Message::new(Name::english("wiki"), Query::new());
         router.forward(&id, msg.clone());
         let result = receiver.recv_timeout(TIMEOUT).unwrap();
         assert_eq!(result.get_message_id(), msg.get_message_id());
@@ -1678,7 +1678,7 @@ mod queues {
     fn can_forward_message() {
         let mut tester = TestQueue::new();
         let mut queue = tester.get_queue();
-        let msg = Message::new(Name::english("wiki".to_string()), Query::new());
+        let msg = Message::new(Name::english("wiki"), Query::new());
         queue.forward(tester.get_preset_id(), msg.clone());
         let result = tester.get_preset_rx().recv_timeout(TIMEOUT).unwrap();
         assert_eq!(result.get_message_id(), msg.get_message_id());
@@ -1700,7 +1700,7 @@ mod queues {
     fn can_register_document_name() {
         let mut tester = TestQueue::new();
         let mut queue = tester.get_queue();
-        let doc_name = Name::english(Uuid::new_v4().to_string());
+        let doc_name = Name::english(Uuid::new_v4());
         let reg_msg = Register::new(
             tester.get_preset_id().clone(),
             RegMsg::AddDocName(doc_name.clone()),
@@ -1724,7 +1724,7 @@ mod queues {
         let mut tester = TestQueue::new();
         let mut queue = tester.get_queue();
         let receiver = tester.get_preset_rx();
-        let doc_name = Name::english(Uuid::new_v4().to_string());
+        let doc_name = Name::english(Uuid::new_v4());
         let reg_msg = Register::new(
             tester.get_preset_id().clone(),
             RegMsg::AddDocName(doc_name.clone()),
@@ -1756,8 +1756,8 @@ mod queues {
         let mut tester = TestQueue::new();
         let mut queue = tester.get_queue();
         let names = [
-            Name::english("task".to_string()),
-            Name::english("recipe".to_string()),
+            Name::english("task"),
+            Name::english("recipe"),
         ];
         for name in names.iter() {
             tester.add_document(name.clone());
@@ -1786,8 +1786,8 @@ mod queues {
         let mut tester = TestQueue::new();
         let mut queue = tester.get_queue();
         let names = [
-            Name::english("task".to_string()),
-            Name::english("recipe".to_string()),
+            Name::english("task"),
+            Name::english("recipe"),
         ];
         let route_req = Path::new(Include::All, Include::All, Include::All);
         let reg_msg = RegMsg::AddRoute(route_req);
@@ -1810,7 +1810,7 @@ mod queues {
     fn does_receiver_only_receives_the_message_once() {
         let mut tester = TestQueue::new();
         let mut queue = tester.get_queue();
-        let name = Name::english("something".to_string());
+        let name = Name::english("something");
         tester.add_document(name.clone());
         let paths = [
             Path::new(Include::All, Include::All, Include::All),
@@ -1845,8 +1845,8 @@ mod queues {
         let mut tester = TestQueue::new();
         let mut queue = tester.get_queue();
         let names = [
-            Name::english("one".to_string()),
-            Name::english("two".to_string()),
+            Name::english("one"),
+            Name::english("two"),
         ];
         let mut inputs: HashMap<Name, Message> = HashMap::new();
         for name in names.iter() {
@@ -1886,8 +1886,8 @@ mod queues {
         let mut tester = TestQueue::new();
         let mut queue = tester.get_queue();
         let names = [
-            Name::english("one".to_string()),
-            Name::english("two".to_string()),
+            Name::english("one"),
+            Name::english("two"),
         ];
         let mut inputs: HashMap<Name, Message> = HashMap::new();
         for name in names.iter() {
@@ -1927,8 +1927,8 @@ mod queues {
         let mut tester = TestQueue::new();
         let mut queue = tester.get_queue();
         let names = [
-            Name::english("one".to_string()),
-            Name::english("two".to_string()),
+            Name::english("one"),
+            Name::english("two"),
         ];
         let paths = [
             Path::new(Include::All, Include::All, Include::Some(Action::Reply)),
@@ -2384,7 +2384,7 @@ mod additions {
     #[test]
     fn can_add_static_string() {
         let mut add = Addition::new();
-        let name = Name::english(Uuid::new_v4().to_string());
+        let name = Name::english(Uuid::new_v4());
         let data = Uuid::new_v4().to_string();
         add.add_field(name.clone(), data.clone());
         let result = add.get_field(&name).unwrap();
@@ -2396,7 +2396,7 @@ mod additions {
 
     fn can_add_uuid() {
         let mut add = Addition::new();
-        let name = Name::english(Uuid::new_v4().to_string());
+        let name = Name::english(Uuid::new_v4());
         let data = Uuid::new_v4();
         add.add_field(name.clone(), data.clone());
         let result = add.get_field(&name).unwrap();
@@ -2408,7 +2408,7 @@ mod additions {
 
     fn can_get_document() {
         let mut add = Addition::new();
-        let name = Name::english(Uuid::new_v4().to_string());
+        let name = Name::english(Uuid::new_v4());
         let data = Uuid::new_v4();
         add.add_field(name.clone(), data.clone());
         let doc: Document = add.get_document();
@@ -2571,9 +2571,9 @@ mod docdefs {
 
     #[test]
     fn can_field_be_added() {
-        let docname = Name::english("tester".to_string());
+        let docname = Name::english("tester");
         let mut docdef = DocDef::new(docname);
-        let name = Name::english(Uuid::new_v4().to_string());
+        let name = Name::english(Uuid::new_v4());
         let field_type = FieldType::Uuid;
         docdef.add_field(name.clone(), field_type.clone());
         let result = docdef.get_field(name).unwrap();
@@ -2585,9 +2585,9 @@ mod docdefs {
 
     #[test]
     fn produces_error_for_bad_fields() {
-        let docname = Name::english("tester".to_string());
+        let docname = Name::english("tester");
         let docdef = DocDef::new(docname);
-        let name = Name::english(Uuid::new_v4().to_string());
+        let name = Name::english(Uuid::new_v4());
         match docdef.get_field(&name) {
             Ok(_) => unreachable!("should return non existant field error"),
             Err(err) => match err {
@@ -2599,15 +2599,15 @@ mod docdefs {
 
     #[test]
     fn can_multiple_fields_be_added() {
-        let docname = Name::english("testing".to_string());
+        let docname = Name::english("testing");
         let mut docdef = DocDef::new(docname);
         let names = ["one", "two", "three"];
         let field_type = FieldType::StaticString;
         for name in names.iter() {
-            docdef.add_field(Name::english(name.to_string()), field_type.clone());
+            docdef.add_field(Name::english(name.clone()), field_type.clone());
         }
         for name in names.iter() {
-            let result = docdef.get_field(Name::english(name.to_string())).unwrap();
+            let result = docdef.get_field(Name::english(name.clone())).unwrap();
             match result.validate(Some("".into())) {
                 Ok(_) => {}
                 Err(err) => unreachable!("got {:?}: should have been a value", err),
@@ -2617,9 +2617,9 @@ mod docdefs {
 
     #[test]
     fn can_change_field_default_to_function() {
-        let docname = Name::english("something".to_string());
+        let docname = Name::english("something");
         let mut docdef = DocDef::new(docname);
-        let name = Name::english("defaultfunction".to_string());
+        let name = Name::english("defaultfunction");
         docdef.add_field(name.clone(), FieldType::StaticString);
         let mut calc = Calculation::new(Operand::Assign);
         calc.add_value(FieldType::StaticString);
@@ -2635,9 +2635,9 @@ mod docdefs {
 
     #[test]
     fn does_set_default_function_error_on_bad_field_name() {
-        let docname = Name::english("something".to_string());
+        let docname = Name::english("something");
         let mut docdef = DocDef::new(docname);
-        let field_name = Name::english("wrong".to_string());
+        let field_name = Name::english("wrong");
         let calc = Calculation::new(Operand::Assign);
         match docdef.set_default(&field_name, calc) {
             Ok(_) => unreachable!("should be an error"),
@@ -2650,9 +2650,9 @@ mod docdefs {
 
     #[test]
     fn does_set_default_value_error_on_bad_field_name() {
-        let docname = Name::english("something".to_string());
+        let docname = Name::english("something");
         let mut docdef = DocDef::new(docname);
-        let field_name = Name::english(Uuid::new_v4().to_string());
+        let field_name = Name::english(Uuid::new_v4());
         let mut calc = Calculation::new(Operand::Assign);
         calc.add_value(Uuid::new_v4());
         match docdef.set_default(&field_name, calc) {
@@ -2666,9 +2666,9 @@ mod docdefs {
 
     #[test]
     fn does_set_default_value_error_on_bad_field_type() {
-        let docname = Name::english("something".to_string());
+        let docname = Name::english("something");
         let mut docdef = DocDef::new(docname);
-        let name = Name::english("defaultvalue".to_string());
+        let name = Name::english("defaultvalue");
         docdef.add_field(name.clone(), FieldType::Uuid);
         let mut calc = Calculation::new(Operand::Assign);
         calc.add_value("fred");
@@ -3246,7 +3246,7 @@ mod queries {
 
     #[test]
     fn holds_calculation_to_run_query() {
-        let name = Name::english(Uuid::new_v4().to_string());
+        let name = Name::english(Uuid::new_v4());
         let data = Uuid::new_v4();
         let mut bad_data = data.clone();
         while bad_data == data {
@@ -3281,7 +3281,7 @@ mod queries {
         let mut calc = Calculation::new(Operand::Assign);
         calc.add_value(Uuid::nil());
         let mut query = Query::new();
-        match query.add(Name::english("name".to_string()), calc) {
+        match query.add(Name::english("name"), calc) {
             Ok(_) => unreachable!("Should have received an error"),
             Err(err) => match err {
                 MTTError::QueryCannotChangeData => {}
@@ -3360,7 +3360,7 @@ mod replies {
 
     #[test]
     fn can_retrieve_documents() {
-        let fieldname = Name::english("field".to_string());
+        let fieldname = Name::english("field");
         let mut doc1 = Document::new();
         doc1.add_field(fieldname.clone(), "one");
         let mut doc2 = Document::new();
@@ -3544,13 +3544,13 @@ mod records {
         }
         let mut name_ids: HashMap<Name, Uuid> = HashMap::new();
         for id in ids.iter() {
-            let name = Name::english(id.to_string());
+            let name = Name::english(id.clone());
             let field_id = names.add_name(name.clone()).unwrap();
             name_ids.insert(name, field_id);
         }
         let mut rec = Record::new(names);
         for id in ids.iter() {
-            let name = Name::english(id.to_string());
+            let name = Name::english(id.clone());
             rec.insert(name, id.clone());
         }
         for (name, id) in name_ids.iter() {
@@ -3577,7 +3577,7 @@ mod records {
     fn does_insert_error_on_bad_field_name() {
         let names = Names::new();
         let mut rec = Record::new(names);
-        let name = Name::english("wrong".to_string());
+        let name = Name::english("wrong");
         match rec.insert(name.clone(), "bad") {
             Ok(_) => unreachable!("should return not found error"),
             Err(err) => match err {
@@ -3591,7 +3591,7 @@ mod records {
     fn does_get_error_on_bad_field_name() {
         let names = Names::new();
         let mut rec = Record::new(names);
-        let name = Name::english("missing".to_string());
+        let name = Name::english("missing");
         match rec.get(&name) {
             Ok(_) => unreachable!("should return not found error"),
             Err(err) => match err {
@@ -3604,7 +3604,7 @@ mod records {
     #[test]
     fn does_get_error_on_missing_data() {
         let mut names = Names::new();
-        let name = Name::english("empty".to_string());
+        let name = Name::english("empty");
         names.add_name(name.clone()).unwrap();
         let mut rec = Record::new(names);
         match rec.get(&name) {
@@ -3618,7 +3618,7 @@ mod records {
 
     #[test]
     fn can_records_hold_multiple_entries() {
-        let field_name = Name::english("field".to_string());
+        let field_name = Name::english("field");
         let mut names = Names::new();
         names.add_name(field_name.clone());
         let count: isize = 5;
@@ -3664,8 +3664,8 @@ mod records {
     #[test]
     fn errors_on_mismatched_entries() {
         let mut names = Names::new();
-        let name1 = Name::english("first".to_string());
-        let name2 = Name::english("second".to_string());
+        let name1 = Name::english("first");
+        let name2 = Name::english("second");
         names.add_name(name1.clone()).unwrap();
         names.add_name(name2.clone()).unwrap();
         let mut rec1 = Record::new(names.clone());
@@ -3759,7 +3759,7 @@ mod documents {
     #[test]
     fn can_add_static_string() {
         let mut add = Document::new();
-        let name = Name::english(Uuid::new_v4().to_string());
+        let name = Name::english(Uuid::new_v4());
         let data = Uuid::new_v4().to_string();
         add.add_field(name.clone(), data.clone());
         let result = add.get_field(&name).unwrap();
@@ -3771,7 +3771,7 @@ mod documents {
 
     fn can_add_uuid() {
         let mut add = Document::new();
-        let name = Name::english(Uuid::new_v4().to_string());
+        let name = Name::english(Uuid::new_v4());
         let data = Uuid::new_v4();
         add.add_field(name.clone(), data.clone());
         let result = add.get_field(&name).unwrap();
@@ -4531,7 +4531,7 @@ mod document_files {
 
     impl TestDocument {
         fn new(field_types: Vec<FieldType>) -> Self {
-            let doc_name = Name::english(Uuid::new_v4().to_string());
+            let doc_name = Name::english(Uuid::new_v4());
             let mut docdef = DocDef::new(doc_name.clone());
             let mut count = 0;
             for field_type in field_types.iter() {
@@ -4623,10 +4623,10 @@ mod document_files {
 
     #[test]
     fn does_not_respond_to_create() {
-        let name = Name::english("quiet".to_string());
+        let name = Name::english("quiet");
         let docdef = DocDef::new(name.clone());
         let mut test_doc: TestDocument = docdef.into();
-        let alt = Name::english("alternate".to_string());
+        let alt = Name::english("alternate");
         test_doc.start();
         let docdef = DocDef::new(alt);
         let msg = Message::new(name.clone(), docdef);
@@ -4642,7 +4642,7 @@ mod document_files {
 
     #[test]
     fn does_document_respond_to_requests() {
-        let name = Name::english("listen".to_string());
+        let name = Name::english("listen");
         let docdef = DocDef::new(name.clone());
         let mut test_doc: TestDocument = docdef.into();
         test_doc.start();
@@ -4685,8 +4685,8 @@ mod document_files {
 
     #[test]
     fn does_not_respond_to_other_document_requests() {
-        let name = Name::english("quiet".to_string());
-        let alt = Name::english("alternate".to_string());
+        let name = Name::english("quiet");
+        let alt = Name::english("alternate");
         let docdef = DocDef::new(name.clone());
         let mut test_doc: TestDocument = docdef.into();
         test_doc.start();
@@ -4717,9 +4717,9 @@ mod document_files {
 
     #[test]
     fn can_document_be_added() {
-        let doc_name = Name::english("document".to_string());
+        let doc_name = Name::english("document");
         let mut docdef = DocDef::new(doc_name.clone());
-        let name = Name::english("field".to_string());
+        let name = Name::english("field");
         let data = Uuid::new_v4();
         docdef.add_field(name.clone(), FieldType::Uuid);
         let mut test_doc: TestDocument = docdef.clone().into();
@@ -4754,9 +4754,9 @@ mod document_files {
 
     #[test]
     fn can_add_multiple_documents() {
-        let doc_name = Name::english("multiple".to_string());
+        let doc_name = Name::english("multiple");
         let mut docdef = DocDef::new(doc_name.clone());
-        let name = Name::english("count".to_string());
+        let name = Name::english("count");
         docdef.add_field(name.clone(), FieldType::Integer);
         let mut test_doc: TestDocument = docdef.clone().into();
         test_doc.start();
@@ -4796,7 +4796,7 @@ mod document_files {
         let mut test_doc = TestDocument::new(Vec::new());
         test_doc.start();
         let queue = test_doc.get_queue();
-        let name = Name::english("bad".to_string());
+        let name = Name::english("bad");
         let mut addition = Addition::new();
         addition.add_field(name.clone(), "doesn't matter");
         queue.send(Message::new(test_doc.get_docdef().get_document_name(), addition)).unwrap();
@@ -4816,7 +4816,7 @@ mod document_files {
         test_doc.start();
         let queue = test_doc.get_queue();
         let mut addition = Addition::new();
-        addition.add_field(Name::english("field0".to_string()), "string");
+        addition.add_field(Name::english("field0"), "string");
         queue.send(Message::new(test_doc.get_docdef().get_document_name(), addition));
         let result = test_doc.get_receiver().recv_timeout(TIMEOUT).unwrap();
         match result.get_action() {
@@ -4840,7 +4840,7 @@ mod document_files {
         test_doc.start();
         let queue = test_doc.get_queue();
         let mut addition = Addition::new();
-        addition.add_field(Name::english("field0".to_string()), 1);
+        addition.add_field(Name::english("field0"), 1);
         queue.send(Message::new(test_doc.get_docdef().get_document_name(), addition));
         let result = test_doc.get_receiver().recv_timeout(TIMEOUT).unwrap();
         match result.get_action() {
@@ -4866,7 +4866,7 @@ mod document_files {
         let mut calc = Calculation::new(Operand::Equal);
         calc.add_value(expected.clone());
         let mut query = Query::new();
-        query.add(Name::english("field0".to_string()), calc);
+        query.add(Name::english("field0"), calc);
         queue.send(Message::new(test_doc.get_docdef().get_document_name(), query));
         let result = test_doc.get_receiver().recv_timeout(TIMEOUT).unwrap();
         let action = result.get_action();
@@ -4880,7 +4880,7 @@ mod document_files {
                     action
                 );
                 for doc in data.clone() {
-                    assert_eq!(doc.get(&Name::english("field0".to_string())).unwrap(), expected.into());
+                    assert_eq!(doc.get(&Name::english("field0")).unwrap(), expected.into());
                 }
             }
             _ => unreachable!("got {:?}: should have been a reply", action),
@@ -4902,7 +4902,7 @@ mod document_files {
         let mut calc = Calculation::new(Operand::Equal);
         calc.add_value(data.clone());
         let mut query = Query::new();
-        query.add(Name::english("field0".to_string()), calc);
+        query.add(Name::english("field0"), calc);
         queue.send(Message::new(test_doc.get_docdef().get_document_name(), query));
         let result = test_doc.get_receiver().recv_timeout(TIMEOUT).unwrap();
         let action = result.get_action();
@@ -4916,7 +4916,7 @@ mod document_files {
                     action
                 );
                 for doc in docs.clone() {
-                    assert_eq!(doc.get(&Name::english("field0".to_string())).unwrap(), data.into());
+                    assert_eq!(doc.get(&Name::english("field0")).unwrap(), data.into());
                 }
             }
             _ => unreachable!("got {:?}: should have been a reply", action),
@@ -4940,10 +4940,10 @@ mod document_files {
         let mut query = Query::new();
         let mut calc = Calculation::new(Operand::Equal);
         calc.add_value("a");
-        query.add(Name::english("field0".to_string()), calc);
+        query.add(Name::english("field0"), calc);
         let mut calc = Calculation::new(Operand::Equal);
         calc.add_value("b");
-        query.add(Name::english("field1".to_string()), calc);
+        query.add(Name::english("field1"), calc);
         doc.send(query).unwrap();
         let result = doc.get_receiver().recv_timeout(TIMEOUT).unwrap();
         let action = result.get_action();
@@ -4953,8 +4953,8 @@ mod document_files {
                 let bfield: Field = "b".into();
                 assert_eq!(data.len(), 1, "should return one entry:\n{:?}", action);
                 for doc in data.clone() {
-                    assert_eq!(doc.get(&Name::english("field0".to_string())).unwrap(), afield);
-                    assert_eq!(doc.get(&Name::english("field1".to_string())).unwrap(), bfield);
+                    assert_eq!(doc.get(&Name::english("field0")).unwrap(), afield);
+                    assert_eq!(doc.get(&Name::english("field1")).unwrap(), bfield);
                 }
             }
             _ => unreachable!("got {:?}: should have been a reply", action),
@@ -4966,8 +4966,8 @@ mod document_files {
         let mut doc =
             TestDocument::new([FieldType::StaticString, FieldType::StaticString].to_vec());
         let docdef = doc.get_docdef_mut();
-        docdef.add_index(&Name::english("field0".to_string()), IndexType::Index);
-        docdef.add_index(&Name::english("field1".to_string()), IndexType::Index);
+        docdef.add_index(&Name::english("field0"), IndexType::Index);
+        docdef.add_index(&Name::english("field1"), IndexType::Index);
         doc.start();
         let values = [
             ["a".into(), "a".into()].to_vec(),
@@ -4981,10 +4981,10 @@ mod document_files {
         let mut query = Query::new();
         let mut calc = Calculation::new(Operand::Equal);
         calc.add_value("a");
-        query.add(Name::english("field0".to_string()), calc);
+        query.add(Name::english("field0"), calc);
         let mut calc = Calculation::new(Operand::Equal);
         calc.add_value("b");
-        query.add(Name::english("field1".to_string()), calc);
+        query.add(Name::english("field1"), calc);
         doc.send(query).unwrap();
         let result = doc.get_receiver().recv_timeout(TIMEOUT).unwrap();
         let action = result.get_action();
@@ -4994,21 +4994,20 @@ mod document_files {
                 let bfield: Field = "b".into();
                 assert_eq!(data.len(), 1, "should return one entry:\n{:?}", action);
                 for doc in data.clone() {
-                    assert_eq!(doc.get(&Name::english("field0".to_string())).unwrap(), afield);
-                    assert_eq!(doc.get(&Name::english("field1".to_string())).unwrap(), bfield);
+                    assert_eq!(doc.get(&Name::english("field0")).unwrap(), afield);
+                    assert_eq!(doc.get(&Name::english("field1")).unwrap(), bfield);
                 }
             }
             _ => unreachable!("got {:?}: should have been a reply", action),
         }
     }
 
-    /*
     #[test]
     fn query_should_work_with_mixed_inexed_fields() {
         let mut doc =
             TestDocument::new([FieldType::StaticString, FieldType::StaticString].to_vec());
         let docdef = doc.get_docdef_mut();
-        docdef.add_index("field0".to_string(), IndexType::Index);
+        docdef.add_index(&Name::english("field0"), IndexType::Index);
         doc.start();
         let values = [
             ["a".into(), "a".into()].to_vec(),
@@ -5022,27 +5021,28 @@ mod document_files {
         let mut query = Query::new();
         let mut calc = Calculation::new(Operand::Equal);
         calc.add_value("a");
-        query.add("field0".to_string(), calc);
+        query.add(Name::english("field0"), calc);
         let mut calc = Calculation::new(Operand::Equal);
         calc.add_value("b");
-        query.add("field1".to_string(), calc);
+        query.add(Name::english("field1"), calc);
         doc.send(query).unwrap();
         let result = doc.get_receiver().recv_timeout(TIMEOUT).unwrap();
         let action = result.get_action();
         match action {
-            MsgAction::Reply(data) => {
+            MsgAction::Records(data) => {
                 let afield: Field = "a".into();
                 let bfield: Field = "b".into();
                 assert_eq!(data.len(), 1, "should return one entry:\n{:?}", action);
-                for doc in data.iter() {
-                    assert_eq!(doc.get_field("field0").unwrap(), afield);
-                    assert_eq!(doc.get_field("field1").unwrap(), bfield);
+                for doc in data.clone() {
+                    assert_eq!(doc.get(&Name::english("field0")).unwrap(), afield);
+                    assert_eq!(doc.get(&Name::english("field1")).unwrap(), bfield);
                 }
             }
             _ => unreachable!("got {:?}: should have been a reply", action),
         }
     }
 
+    /*
     #[test]
     fn errors_on_bad_field_name() {
         let (docdef, doc_name) = create_docdef(Vec::new());
@@ -5682,7 +5682,7 @@ mod createdocs {
     #[test]
     #[ignore]
     fn create_document_creation() {
-        let name = Name::english("project".to_string());
+        let name = Name::english("project");
         let routes = [RouteRequest::new(
             Include::All,
             Include::All,
@@ -5713,7 +5713,7 @@ mod createdocs {
     #[test]
     #[ignore]
     fn does_duplicates_generate_error() {
-        let name = Name::english("duplicate".to_string());
+        let name = Name::english("duplicate");
         let routes = [
             RouteRequest::new(Include::All, Include::All, Include::Some(Action::Reply)),
             RouteRequest::new(Include::All, Include::All, Include::Some(Action::Error)),