Mention ArrowModule in serialization and ktor sections

content/docs/learn/integrations.md

@@ -78,6 +78,16 @@ The main point of contact between Ktor and Arrow is in
 If you're using kotlinx.serialization, you need no further changes other than
 importing the serializers with `@UseSerializers`.
 
+If you want to use Arrow Core types directly as your request or response models, you will need to include the `ArrowModule` in your serializers module:
+
+```kotlin
+install(ContentNegotiation) {
+  json(Json {
+    serializersModule = ArrowModule
+  })
+}
+```
+
 If you're using Jackson, you can use the
 [custom mapper](https://github.com/arrow-kt/arrow-integrations#ktor),
 and pass it to the `ContentNegotiation` configuration.

content/docs/learn/quickstart/serialization.md

@@ -20,19 +20,18 @@ If you're using kotlinx.serialization, you need to depend on the
 Declare your serializable types as usual. However, when one of the fields
 mentions a type from Arrow Core,
 
-```
+```kotlin
 @Serializable
 data class Book(val title: String, val authors: NonEmptyList<String>)
 ```
 
 you need to "import" the serializer into the file. The easiest way is to
 include a `UseSerializers` annotation at the very top.
 
-```
+```kotlin
 @file:UseSerializers(
   EitherSerializer::class,
   IorSerializer::class,
-  ValidatedSerializer::class,
   OptionSerializer::class,
   NonEmptyListSerializer::class,
   NonEmptySetSerializer::class
@@ -43,6 +42,30 @@ The list above mentions all the serializers, but you only need to add those
 which are used in your fields. Don't worry too much: if you miss one, the
 kotlinx.serialization plug-in gives you an error.
 
+Additionally, you can use `arrow.core.serialization.ArrowModule` to register run-time [contextual serialization](https://github.com/Kotlin/kotlinx.serialization/blob/master/docs/serializers.md#contextual-serialization) support of the Arrow Core types. 
+
+```kotlin
+val format = Json { serializersModule = ArrowModule }
+```
+
+or by merging with another serializers module
+
+```kotlin
+val format = Json { serializersModule = myModule + ArrowModule }
+```
+
+This will allow for use of the Arrow Core types as the value to be serialized without specifying the serializer explicitly:
+
+```kotlin
+val payload = format.encodeToString(nonEmptyListOf("hello", "world"))
+```
+
+:::note
+
+Using `@UseSerializers` to provide static _compile-time_ serialization of fields containing Arrow Core types is usually preferable to annotating fields with `@Contextual` and relying on _run-time_ resolution, wherever possible.
+
+:::
+
 :::info Additional reading
 
 [_Marshalling Arrow Types in Ktor_](https://garthgilmour.medium.com/marshalling-arrow-types-in-ktor-bc471aa3650)