diff --git a/01.workspace/heave/src/fun/sqlite_init_db.rs b/01.workspace/heave/src/fun/sqlite_init_db.rs
index 2ab25dd..53b4a03 100644
--- a/01.workspace/heave/src/fun/sqlite_init_db.rs
+++ b/01.workspace/heave/src/fun/sqlite_init_db.rs
@@ -26,9 +26,9 @@ pub fn run(path: &path::Path) -> result::Result<(), FailedTo> {
         CREATE INDEX IF NOT EXISTS attribute_entity_id ON attribute (entity_id);
         "#;
     let connection = Connection::open(path)
-        .map_err(|sqlite_error| sqlite::FailedTo::OpenConnection(sqlite_error))?;
+        .map_err(sqlite::FailedTo::OpenConnection)?;
     connection
         .execute_batch(init_statement)
-        .map_err(|sqlite_error| sqlite::FailedTo::ExecuteBatch(sqlite_error))?;
+        .map_err(sqlite::FailedTo::ExecuteBatch)?;
     Ok(())
 }
diff --git a/01.workspace/heave/src/fun/sqlite_load_attributes.rs b/01.workspace/heave/src/fun/sqlite_load_attributes.rs
index ecaf778..55b94dd 100644
--- a/01.workspace/heave/src/fun/sqlite_load_attributes.rs
+++ b/01.workspace/heave/src/fun/sqlite_load_attributes.rs
@@ -17,10 +17,10 @@ const SELECT_ATTRIBUTE_BY_FK: &str = r#"
 pub fn run(transaction: &Transaction, entity: &mut Entity) -> Result<(), FailedTo> {
     let mut select_attributes_statement = transaction
         .prepare(SELECT_ATTRIBUTE_BY_FK)
-        .map_err(|sqlite_error| sqlite::FailedTo::PrepareStatement(sqlite_error))?;
+        .map_err(sqlite::FailedTo::PrepareStatement)?;
     let attributes = select_attributes_statement
         .query_map([&entity.id], sqlite::map::row_to_attribute)
-        .map_err(|sqlite_error| sqlite::FailedTo::ExecuteQuery(sqlite_error))?;
+        .map_err(sqlite::FailedTo::ExecuteQuery)?;
     for attribute in attributes {
         let attribute = attribute.map_err(|_| FailedTo::MapAttribute)?;
         entity.attributes.insert(attribute.id.clone(), attribute);
diff --git a/01.workspace/heave/src/fun/sqlite_load_by_class.rs b/01.workspace/heave/src/fun/sqlite_load_by_class.rs
index 69ff6d1..8d498ae 100644
--- a/01.workspace/heave/src/fun/sqlite_load_by_class.rs
+++ b/01.workspace/heave/src/fun/sqlite_load_by_class.rs
@@ -9,17 +9,17 @@ const SELECT_ENTITY_BY_CLASS: &str = r#"
 pub fn run(path: &path::Path, entity_class: &str) -> Result<Vec<Entity>, FailedTo> {
     let mut entities = Vec::<Entity>::new();
     let mut connection = Connection::open(path)
-        .map_err(|sqlite_error| sqlite::FailedTo::OpenConnection(sqlite_error))?;
+        .map_err(sqlite::FailedTo::OpenConnection)?;
     let mut transaction = connection
         .transaction()
-        .map_err(|sqlite_error| sqlite::FailedTo::BeginTransaction(sqlite_error))?;
+        .map_err(sqlite::FailedTo::BeginTransaction)?;
     transaction.set_drop_behavior(DropBehavior::Commit);
     let mut statement = transaction
         .prepare(SELECT_ENTITY_BY_CLASS)
-        .map_err(|sqlite_error| sqlite::FailedTo::PrepareStatement(sqlite_error))?;
+        .map_err(sqlite::FailedTo::PrepareStatement)?;
     let result = statement
         .query_map([entity_class], sqlite::map::row_to_entity)
-        .map_err(|sqlite_error| sqlite::FailedTo::ExecuteQuery(sqlite_error))?;
+        .map_err(sqlite::FailedTo::ExecuteQuery)?;
     for entity in result {
         let mut entity = entity.map_err(|_| FailedTo::MapEntity)?;
         sqlite::load::attributes(&transaction, &mut entity)?;
diff --git a/01.workspace/heave/src/fun/sqlite_load_by_filter.rs b/01.workspace/heave/src/fun/sqlite_load_by_filter.rs
index 54bcc84..8544710 100644
--- a/01.workspace/heave/src/fun/sqlite_load_by_filter.rs
+++ b/01.workspace/heave/src/fun/sqlite_load_by_filter.rs
@@ -4,20 +4,20 @@ use rusqlite::*;
 pub fn run(path: &path::Path, filter: &Filter) -> Result<Vec<Entity>, FailedTo> {
     let mut entities = Vec::<Entity>::new();
     let mut connection = Connection::open(path)
-        .map_err(|sqlite_error| sqlite::FailedTo::OpenConnection(sqlite_error))?;
+        .map_err(sqlite::FailedTo::OpenConnection)?;
     let mut transaction = connection
         .transaction()
-        .map_err(|sqlite_error| sqlite::FailedTo::BeginTransaction(sqlite_error))?;
+        .map_err(sqlite::FailedTo::BeginTransaction)?;
     transaction.set_drop_behavior(DropBehavior::Commit);
     let select_entity_by_filter = sqlite::build::statement(filter)?;
     let params = sqlite::build::params(filter)?;
     let params: Vec<&dyn ToSql> = params.iter().map(|p| p.as_ref() as &dyn ToSql).collect();
     let mut statement = transaction
         .prepare(&select_entity_by_filter)
-        .map_err(|sqlite_error| sqlite::FailedTo::PrepareStatement(sqlite_error))?;
+        .map_err(sqlite::FailedTo::PrepareStatement)?;
     let result = statement
         .query_map(&params[..], sqlite::map::row_to_entity)
-        .map_err(|sqlite_error| sqlite::FailedTo::ExecuteQuery(sqlite_error))?;
+        .map_err(sqlite::FailedTo::ExecuteQuery)?;
     for entity in result {
         let mut entity = entity.map_err(|_| FailedTo::MapEntity)?;
         sqlite::load::attributes(&transaction, &mut entity)?;
diff --git a/01.workspace/heave/src/fun/sqlite_load_by_id.rs b/01.workspace/heave/src/fun/sqlite_load_by_id.rs
index ed51cba..fcd50c6 100644
--- a/01.workspace/heave/src/fun/sqlite_load_by_id.rs
+++ b/01.workspace/heave/src/fun/sqlite_load_by_id.rs
@@ -8,15 +8,15 @@ const SELECT_ENTITY_BY_ID: &str = r#"
 
 pub fn run(path: &path::Path, entity_id: &str) -> Result<Option<Entity>, FailedTo> {
     let mut connection = Connection::open(path)
-        .map_err(|sqlite_error| sqlite::FailedTo::OpenConnection(sqlite_error))?;
+        .map_err(sqlite::FailedTo::OpenConnection)?;
     let mut transaction = connection
         .transaction()
-        .map_err(|sqlite_error| sqlite::FailedTo::BeginTransaction(sqlite_error))?;
+        .map_err(sqlite::FailedTo::BeginTransaction)?;
     transaction.set_drop_behavior(DropBehavior::Commit);
     let mut entity = transaction
         .query_one(SELECT_ENTITY_BY_ID, [entity_id], sqlite::map::row_to_entity)
         .optional()
-        .map_err(|sqlite_error| sqlite::FailedTo::ExecuteQuery(sqlite_error))?;
+        .map_err(sqlite::FailedTo::ExecuteQuery)?;
     if let Some(ref mut entity) = entity {
         sqlite::load::attributes(&transaction, entity)?;
         entity.state = EntityState::Loaded;
diff --git a/01.workspace/heave/src/fun/sqlite_persist_catalog.rs b/01.workspace/heave/src/fun/sqlite_persist_catalog.rs
index 59661fb..06999e1 100644
--- a/01.workspace/heave/src/fun/sqlite_persist_catalog.rs
+++ b/01.workspace/heave/src/fun/sqlite_persist_catalog.rs
@@ -38,7 +38,7 @@ fn write_attribute(
         INSERT_ATTRIBUTE_STATEMENT_TEMPLATE.replace("{column}", column);
     transaction
         .execute(&insert_attribute_statement, attribute_values)
-        .map_err(|sqlite_error| sqlite::FailedTo::ExecuteStatement(sqlite_error))?;
+        .map_err(sqlite::FailedTo::ExecuteStatement)?;
     Ok(())
 }
 
@@ -46,7 +46,7 @@ fn delete_entity(entity: &Entity, transaction: &rusqlite::Transaction) -> Result
     let entity_id = [&entity.id];
     transaction
         .execute(DELETE_ENTITY_STATEMENT, entity_id)
-        .map_err(|sqlite_error| sqlite::FailedTo::ExecuteStatement(sqlite_error))?;
+        .map_err(sqlite::FailedTo::ExecuteStatement)?;
     Ok(())
 }
 
@@ -55,10 +55,10 @@ fn write_entity(entity: &Entity, transaction: &rusqlite::Transaction) -> Result<
     let entity_values = (&entity.id, &entity.class, &entity.subclass, entity.ref_date);
     transaction
         .execute(DELETE_ENTITY_STATEMENT, entity_id)
-        .map_err(|sqlite_error| sqlite::FailedTo::ExecuteStatement(sqlite_error))?;
+        .map_err(sqlite::FailedTo::ExecuteStatement)?;
     transaction
         .execute(INSERT_ENTITY_STATEMENT, entity_values)
-        .map_err(|sqlite_error| sqlite::FailedTo::ExecuteStatement(sqlite_error))?;
+        .map_err(sqlite::FailedTo::ExecuteStatement)?;
     for attribute in entity.attributes.values() {
         write_attribute(attribute, entity, transaction)?;
     }
@@ -67,10 +67,10 @@ fn write_entity(entity: &Entity, transaction: &rusqlite::Transaction) -> Result<
 
 pub fn run(path: &path::Path, items: &HashMap<String, Entity>) -> result::Result<(), FailedTo> {
     let mut connection = Connection::open(path)
-        .map_err(|sqlite_error| sqlite::FailedTo::OpenConnection(sqlite_error))?;
+        .map_err(sqlite::FailedTo::OpenConnection)?;
     let transaction = connection
         .transaction()
-        .map_err(|sqlite_error| sqlite::FailedTo::BeginTransaction(sqlite_error))?;
+        .map_err(sqlite::FailedTo::BeginTransaction)?;
     for entity in items.values().filter(|item| {
         item.state == EntityState::New
             || item.state == EntityState::Updated
@@ -84,6 +84,6 @@ pub fn run(path: &path::Path, items: &HashMap<String, Entity>) -> result::Result
     }
     transaction
         .commit()
-        .map_err(|sqlite_error| sqlite::FailedTo::CommitTransaction(sqlite_error))?;
+        .map_err(sqlite::FailedTo::CommitTransaction)?;
     Ok(())
 }