diff --git a/README.md b/README.md
index 7914a2a..8e85deb 100644
--- a/README.md
+++ b/README.md
@@ -52,6 +52,7 @@ Peri supports a variety of types to ensure your data is validated accurately. Be
 | `{:custom, {MyModule, :my_validation, [arg1, arg2]}}` | Same as `{:custom, {MyModule, :my_validation}}` but you can pass extra arguments to your validation function. Note that the value of the field is always the first argument. |
 | `{:cond, condition, true_type, else_type}` | Conditionally validates a field based on the result of a condition function.                    |
 | `{:dependent, field, condition, type}`    | Validates a field based on the value of another field.                                          |
+| `{type, {:default, default}}`             | Validates a field exists based on `type`, if not, return the `default` value                                          |
 
 These types provide flexibility and control over how data is validated, enabling robust and precise schema definitions.
 
diff --git a/lib/peri.ex b/lib/peri.ex
index 3228538..059577d 100644
--- a/lib/peri.ex
+++ b/lib/peri.ex
@@ -1,11 +1,20 @@
 defmodule Peri do
   @moduledoc """
   Peri is a schema validation library for Elixir, inspired by Clojure's Plumatic Schema.
-  It focuses on validating raw maps and supports nested schemas and optional fields.
+  It provides a flexible and powerful way to define and validate data structures using schemas. 
+  The library supports nested schemas, optional fields, custom validation functions, and various type constraints.
+
+  ## Key Features
+
+  - **Simple and Nested Schemas**: Define schemas that can handle complex, nested data structures.
+  - **Optional and Required Fields**: Specify fields as optional or required with type constraints.
+  - **Custom Validation Functions**: Use custom functions to validate fields.
+  - **Comprehensive Error Handling**: Provides detailed error messages for validation failures.
+  - **Type Constraints**: Supports various types including enums, lists, tuples, and more.
 
   ## Usage
 
-  To define a schema, use the `defschema` macro. By default, all fields in the schema are optional unless specified as `{:required, type}`.
+  To define a schema, use the `defschema` macro. By default, all fields in the schema are optional unless specified otherwise.
 
   ```elixir
   defmodule MySchemas do
@@ -33,7 +42,13 @@ defmodule Peri do
   You can then use the schema to validate data:
 
   ```elixir
-  user_data = %{name: "John", age: 30, email: "john@example.com", address: %{street: "123 Main St", city: "Somewhere"}, tags: ["science", "funky"], role: :admin, geolocation: {12.2, 34.2}, rating: 9}
+  user_data = %{
+    name: "John", age: 30, email: "john@example.com",
+    address: %{street: "123 Main St", city: "Somewhere"},
+    tags: ["science", "funky"], role: :admin,
+    geolocation: {12.2, 34.2}, rating: 9
+  }
+
   case MySchemas.user(user_data) do
     {:ok, valid_data} -> IO.puts("Data is valid!")
     {:error, errors} -> IO.inspect(errors, label: "Validation errors")
@@ -47,16 +62,49 @@ defmodule Peri do
   - `:float` - Validates that the field is a float.
   - `:boolean` - Validates that the field is a boolean.
   - `:atom` - Validates that the field is an atom.
-  - `:any` - Allow any datatype.
+  - `:any` - Allows any datatype.
   - `{:required, type}` - Marks the field as required and validates it according to the specified type.
-  - `:map` - Validates that the field is a map without checking nested schema.
+  - `:map` - Validates that the field is a map.
   - `{:either, {type_1, type_2}}` - Validates that the field is either of `type_1` or `type_2`.
   - `{:oneof, types}` - Validates that the field is at least one of the provided types.
-  - `{:list, type}` - Validates that the field is a list where elements belongs to a determined type.
-  - `{:tuple, types}` - Validates that the field is a tuple with determined size and each element have your own type validation (sequential).
-  - `{custom, anonymous_fun_arity_1}` - Validates that the field passes on the callback, the function needs to return either `:ok` or `{:error, reason}` where `reason` should be a string.
-  - `{:custom, {MyModule, :my_validation}}` - Same as `{custom, anonymous_fun_arity_1}` but you pass a remote module and a function name as atom.
-  - `{:custom, {MyModule, :my_validation, [arg1, arg2]}}` - Same as `{:custom, {MyModule, :my_validation}}` but you can pass extra arguments to your validation function. Note that the value of the field is always the first argument.
+  - `{:list, type}` - Validates that the field is a list with elements of the specified type.
+  - `{:tuple, types}` - Validates that the field is a tuple with the specified types in sequence.
+  - `{:custom, anonymous_fun_arity_1}` - Validates that the field passes the callback function.
+  - `{:custom, {MyModule, :my_validation}}` - Validates using a function from a specific module.
+  - `{:custom, {MyModule, :my_validation, [arg1, arg2]}}` - Same as above but allows extra arguments.
+  -	`{:cond, condition, true_type, else_type}` - Validates the field based on a condition.
+  -	`{:dependent, field, condition, type}` - Validates the field based on another field’s value.
+  -	`{type, {:default, default}}` - Sets a default value for a field if it is nil.
+
+  ## Error Handling
+
+  Peri provides detailed error messages that include the path to the invalid data, the expected and actual values, and custom error messages for custom validations.
+
+  ## Functions
+
+  - `validate/2` - Validates data against a schema.
+  - `conforms?/2` - Checks if data conforms to a schema.
+  - `validate_schema/1` - Validates the schema definition.
+
+  ## Example
+
+  ```elixir
+  defmodule MySchemas do
+    import Peri
+
+    defschema :user, %{
+      name: :string,
+      age: :integer,
+      email: {:required, :string}
+    }
+  end
+
+  user_data = %{name: "John", age: 30, email: "john@example.com"}
+  case MySchemas.user(user_data) do
+    {:ok, valid_data} -> IO.puts("Data is valid!")
+    {:error, errors} -> IO.inspect(errors, label: "Validation errors")
+  end
+  ```
   """
 
   @doc """
@@ -157,6 +205,9 @@ defmodule Peri do
       :ok ->
         {:ok, data}
 
+      {:ok, result} ->
+        {:ok, result}
+
       {:error, reason, info} ->
         {:error, Peri.Error.new_single(reason, info)}
     end
@@ -240,6 +291,13 @@ defmodule Peri do
   defp validate_field(val, :list, _data) when is_list(val), do: :ok
   defp validate_field(nil, {:required, _}, _data), do: {:error, "is required", []}
 
+  defp validate_field(_val, {:required, {type, {:default, _}}}, _data) do
+    template =
+      "cannot set default value of default@example.com for required field of type %{type}"
+
+    {:ok, template, [type: type]}
+  end
+
   defp validate_field(m, {:required, :map}, _data) when m == %{},
     do: {:error, "cannot be empty", []}
 
@@ -248,6 +306,15 @@ defmodule Peri do
 
   defp validate_field([], {:required, {:list, _}}, _data), do: {:error, "cannot be empty", []}
   defp validate_field(val, {:required, type}, data), do: validate_field(val, type, data)
+
+  defp validate_field(val, {type, {:default, default}}, data) do
+    val = if is_nil(val), do: default, else: val
+
+    with :ok <- validate_field(val, type, data) do
+      {:ok, val}
+    end
+  end
+
   defp validate_field(nil, _, _data), do: :ok
 
   defp validate_field(val, {:custom, callback}, _data) when is_function(callback, 1) do
@@ -310,21 +377,30 @@ defmodule Peri do
     end)
   end
 
-  defp validate_field(val, {:tuple, types}, data) when is_tuple(val) do
-    if tuple_size(val) == length(types) do
+  defp validate_field(source, {:tuple, types}, data) when is_tuple(source) do
+    if tuple_size(source) == length(types) do
       Enum.with_index(types)
-      |> Enum.reduce_while(:ok, fn {type, index}, :ok ->
-        case validate_field(elem(val, index), type, data) do
+      |> Enum.reduce_while({:ok, []}, fn {type, index}, {:ok, vals} ->
+        case validate_field(elem(source, index), type, data) do
           :ok ->
-            {:cont, :ok}
+            {:cont, {:ok, vals}}
+
+          {:ok, val} ->
+            {:cont, {:ok, [val | vals]}}
 
           {:error, reason, nested_info} ->
             info = [index: index] ++ nested_info
             {:halt, {:error, "tuple element %{index}: #{reason}", info}}
         end
       end)
+      |> then(fn
+        :ok -> :ok
+        {:ok, []} -> :ok
+        {:ok, vals} -> {:ok, List.to_tuple(Enum.reverse(vals))}
+        {:error, reason, info} -> {:error, reason, info}
+      end)
     else
-      info = [length: length(types), actual: length(Tuple.to_list(val))]
+      info = [length: length(types), actual: length(Tuple.to_list(source))]
       template = "expected tuple of size %{length} received tuple with %{actual} length"
       {:error, template, info}
     end
@@ -357,7 +433,7 @@ defmodule Peri do
 
   defp validate_field(data, schema, _data) when is_enumerable(data) do
     case traverse_schema(schema, Peri.Parser.new(data)) do
-      %Peri.Parser{errors: []} -> :ok
+      %Peri.Parser{errors: []} = parser -> {:ok, parser.data}
       %Peri.Parser{errors: errors} -> {:error, errors}
     end
   end
@@ -367,6 +443,59 @@ defmodule Peri do
     {:error, "expected type of %{expected} received %{actual} value", info}
   end
 
+  @doc """
+  Validates a schema definition to ensure it adheres to the expected structure and types.
+
+  This function can handle both simple and complex schema definitions, including nested schemas, custom validation functions, and various type constraints.
+
+  ## Parameters
+
+    - `schema` - The schema definition to be validated. It can be a map or a keyword list representing the schema.
+
+  ## Returns
+
+    - `{:ok, schema}` - If the schema is valid, returns the original schema.
+    - `{:error, errors}` - If the schema is invalid, returns an error tuple with detailed error information.
+
+  ## Examples
+
+    Validating a simple schema:
+    
+    ```elixir
+    schema = %{
+      name: :string,
+      age: :integer,
+      email: {:required, :string}
+    }
+    assert {:ok, ^schema} = validate_schema(schema)
+    ```
+
+    Validating a nested schema:
+
+    ```elixir
+    schema = %{
+      user: %{
+        name: :string,
+        profile: %{
+          age: {:required, :integer},
+          email: {:required, :string}
+        }
+      }
+    }
+    assert {:ok, ^schema} = validate_schema(schema)
+    ```
+
+    Handling invalid schema definition:
+
+    ```elixir
+    schema = %{
+      name: :str,
+      age: :integer,
+      email: {:required, :string}
+    }
+    assert {:error, _errors} = validate_schema(schema)
+    ```
+  """
   def validate_schema(schema) when is_enumerable(schema) do
     case traverse_definition(schema, Peri.Parser.new(schema)) do
       %Peri.Parser{errors: [], data: data} -> {:ok, data}
diff --git a/test/peri_test.exs b/test/peri_test.exs
index fac21a0..3943bc0 100644
--- a/test/peri_test.exs
+++ b/test/peri_test.exs
@@ -1166,180 +1166,180 @@ defmodule PeriTest do
     end
   end
 
-  # defschema(:default_values, %{
-  #   name: {:string, {:default, "Anonymous"}},
-  #   age: {:integer, {:default, 0}},
-  #   email: {:required, :string}
-  # })
-
-  # defschema(:nested_default_values, %{
-  #   user: %{
-  #     name: {:string, {:default, "John Doe"}},
-  #     profile:
-  #       {:required,
-  #        %{
-  #          email: {:string, {:default, "default@example.com"}},
-  #          address:
-  #            {:required,
-  #             %{
-  #               street: {:string, {:default, "123 Main St"}},
-  #               number: {:integer, {:default, 1}}
-  #             }}
-  #        }}
-  #   }
-  # })
-
-  # defschema(:invalid_nested_default_values, %{
-  #   user: %{
-  #     name: {:string, {:default, "John Doe"}},
-  #     profile:
-  #       {:required,
-  #        %{
-  #          age: {:required, :integer},
-  #          email: {:required, {:string, {:default, "default@example.com"}}},
-  #          address: %{
-  #            street: {:string, {:default, "123 Main St"}},
-  #            number: {:integer, {:default, 1}}
-  #          }
-  #        }}
-  #   }
-  # })
-
-  # describe "default values schema validation" do
-  #   test "applies default values when fields are missing" do
-  #     data = %{email: "user@example.com"}
-  #     expected_data = %{name: "Anonymous", age: 0, email: "user@example.com"}
-  #     assert {:ok, ^expected_data} = default_values(data)
-  #   end
-
-  #   test "does not override provided values with defaults" do
-  #     data = %{name: "Alice", age: 25, email: "alice@example.com"}
-  #     assert {:ok, ^data} = default_values(data)
-  #   end
-
-  #   test "handles missing required fields" do
-  #     data = %{name: "Alice", age: 25}
-
-  #     assert {:error, [%Peri.Error{path: [:email], message: "is required"}]} =
-  #              default_values(data)
-  #   end
-  # end
-
-  # describe "nested default values schema validation" do
-  #   test "applies default values in nested schema" do
-  #     data = %{user: %{profile: %{email: nil, address: %{number: nil, street: nil}}}}
-
-  #     expected_data = %{
-  #       user: %{
-  #         name: "John Doe",
-  #         profile: %{
-  #           email: "default@example.com",
-  #           address: %{street: "123 Main St", number: 1}
-  #         }
-  #       }
-  #     }
-
-  #     assert {:ok, ^expected_data} = nested_default_values(data)
-  #   end
-
-  #   test "does not override provided values in nested schema" do
-  #     data = %{
-  #       user: %{
-  #         name: "Jane Doe",
-  #         profile: %{
-  #           email: "jane@example.com",
-  #           address: %{street: "456 Elm St", number: 99}
-  #         }
-  #       }
-  #     }
-
-  #     assert {:ok, ^data} = nested_default_values(data)
-  #   end
-
-  #   test "required fields should not receive default values" do
-  #     data = %{user: %{profile: %{age: 30}}}
-
-  #     assert {
-  #              :error,
-  #              [
-  #                %Peri.Error{
-  #                  path: [:user],
-  #                  key: :user,
-  #                  content: nil,
-  #                  message: nil,
-  #                  errors: [
-  #                    %Peri.Error{
-  #                      path: [:user, :profile],
-  #                      key: :profile,
-  #                      content: nil,
-  #                      message: nil,
-  #                      errors: [
-  #                        %Peri.Error{
-  #                          path: [:user, :profile, :email],
-  #                          key: :email,
-  #                          content: %{
-  #                            type: :string,
-  #                            value: "default@example.com",
-  #                            schema: %{
-  #                              address: %{
-  #                                number: {:integer, {:default, 1}},
-  #                                street: {:string, {:default, "123 Main St"}}
-  #                              },
-  #                              age: {:required, :integer},
-  #                              email: {:required, {:string, {:default, "default@example.com"}}}
-  #                            }
-  #                          },
-  #                          message:
-  #                            "cannot set default value of default@example.com for required field of type :string",
-  #                          errors: nil
-  #                        }
-  #                      ]
-  #                    }
-  #                  ]
-  #                }
-  #              ]
-  #            } = invalid_nested_default_values(data)
-  #   end
-  # end
-
-  # defschema(:simple_list, [
-  #   {:name, {:string, {:default, "Default Name"}}},
-  #   {:age, {:integer, {:default, 18}}},
-  #   {:email, {:required, :string}}
-  # ])
-
-  # defschema(
-  #   :simple_tuple,
-  #   {:tuple,
-  #    [
-  #      {:integer, {:default, 0}},
-  #      {:string, {:default, "Unknown"}}
-  #    ]}
-  # )
-
-  # describe "simple list schema validation" do
-  #   test "applies default values for missing fields in keyword list schema" do
-  #     data = [email: "user@example.com"]
-  #     expected_data = [age: 18, name: "Default Name", email: "user@example.com"]
-  #     assert {:ok, ^expected_data} = simple_list(data)
-  #   end
-
-  #   test "does not override provided values in keyword list schema" do
-  #     data = [name: "Alice", age: 25, email: "alice@example.com"]
-  #     assert {:ok, ^data} = simple_list(data)
-  #   end
-  # end
-
-  # describe "simple tuple schema validation" do
-  #   test "applies default values for missing elements in tuple schema" do
-  #     data = {nil, nil}
-  #     expected_data = {0, "Unknown"}
-  #     assert {:ok, ^expected_data} = simple_tuple(data)
-  #   end
-
-  #   test "does not override provided values in tuple schema" do
-  #     data = {42, "Provided"}
-  #     assert {:ok, ^data} = simple_tuple(data)
-  #   end
-  # end
+  defschema(:default_values, %{
+    name: {:string, {:default, "Anonymous"}},
+    age: {:integer, {:default, 0}},
+    email: {:required, :string}
+  })
+
+  defschema(:nested_default_values, %{
+    user: %{
+      name: {:string, {:default, "John Doe"}},
+      profile:
+        {:required,
+         %{
+           email: {:string, {:default, "default@example.com"}},
+           address:
+             {:required,
+              %{
+                street: {:string, {:default, "123 Main St"}},
+                number: {:integer, {:default, 1}}
+              }}
+         }}
+    }
+  })
+
+  defschema(:invalid_nested_default_values, %{
+    user: %{
+      name: {:string, {:default, "John Doe"}},
+      profile:
+        {:required,
+         %{
+           age: {:required, :integer},
+           email: {:required, {:string, {:default, "default@example.com"}}},
+           address: %{
+             street: {:string, {:default, "123 Main St"}},
+             number: {:integer, {:default, 1}}
+           }
+         }}
+    }
+  })
+
+  describe "default values schema validation" do
+    test "applies default values when fields are missing" do
+      data = %{email: "user@example.com"}
+      expected_data = %{name: "Anonymous", age: 0, email: "user@example.com"}
+      assert {:ok, ^expected_data} = default_values(data)
+    end
+
+    test "does not override provided values with defaults" do
+      data = %{name: "Alice", age: 25, email: "alice@example.com"}
+      assert {:ok, ^data} = default_values(data)
+    end
+
+    test "handles missing required fields" do
+      data = %{name: "Alice", age: 25}
+
+      assert {:error, [%Peri.Error{path: [:email], message: "is required"}]} =
+               default_values(data)
+    end
+  end
+
+  describe "nested default values schema validation" do
+    test "applies default values in nested schema" do
+      data = %{user: %{profile: %{email: nil, address: %{number: nil, street: nil}}}}
+
+      expected_data = %{
+        user: %{
+          name: "John Doe",
+          profile: %{
+            email: "default@example.com",
+            address: %{street: "123 Main St", number: 1}
+          }
+        }
+      }
+
+      assert {:ok, ^expected_data} = nested_default_values(data)
+    end
+
+    test "does not override provided values in nested schema" do
+      data = %{
+        user: %{
+          name: "Jane Doe",
+          profile: %{
+            email: "jane@example.com",
+            address: %{street: "456 Elm St", number: 99}
+          }
+        }
+      }
+
+      assert {:ok, ^data} = nested_default_values(data)
+    end
+
+    test "required fields should not receive default values" do
+      data = %{user: %{profile: %{age: 30}}}
+
+      assert {
+               :error,
+               [
+                 %Peri.Error{
+                   path: [:user],
+                   key: :user,
+                   content: nil,
+                   message: nil,
+                   errors: [
+                     %Peri.Error{
+                       path: [:user, :profile],
+                       key: :profile,
+                       content: nil,
+                       message: nil,
+                       errors: [
+                         %Peri.Error{
+                           path: [:user, :profile, :email],
+                           key: :email,
+                           content: %{
+                             type: :string,
+                             value: "default@example.com",
+                             schema: %{
+                               address: %{
+                                 number: {:integer, {:default, 1}},
+                                 street: {:string, {:default, "123 Main St"}}
+                               },
+                               age: {:required, :integer},
+                               email: {:required, {:string, {:default, "default@example.com"}}}
+                             }
+                           },
+                           message:
+                             "cannot set default value of default@example.com for required field of type :string",
+                           errors: nil
+                         }
+                       ]
+                     }
+                   ]
+                 }
+               ]
+             } = invalid_nested_default_values(data)
+    end
+  end
+
+  defschema(:simple_list, [
+    {:name, {:string, {:default, "Default Name"}}},
+    {:age, {:integer, {:default, 18}}},
+    {:email, {:required, :string}}
+  ])
+
+  defschema(
+    :simple_tuple,
+    {:tuple,
+     [
+       {:integer, {:default, 0}},
+       {:string, {:default, "Unknown"}}
+     ]}
+  )
+
+  describe "simple list schema validation" do
+    test "applies default values for missing fields in keyword list schema" do
+      data = [email: "user@example.com"]
+      expected_data = [age: 18, name: "Default Name", email: "user@example.com"]
+      assert {:ok, ^expected_data} = simple_list(data)
+    end
+
+    test "does not override provided values in keyword list schema" do
+      data = [name: "Alice", age: 25, email: "alice@example.com"]
+      assert {:ok, ^data} = simple_list(data)
+    end
+  end
+
+  describe "simple tuple schema validation" do
+    test "applies default values for missing elements in tuple schema" do
+      data = {nil, nil}
+      expected_data = {0, "Unknown"}
+      assert {:ok, ^expected_data} = simple_tuple(data)
+    end
+
+    test "does not override provided values in tuple schema" do
+      data = {42, "Provided"}
+      assert {:ok, ^data} = simple_tuple(data)
+    end
+  end
 end