Update docs

docs/en/src/SUMMARY.md

@@ -13,6 +13,7 @@
     - [Union](define_union.md)
     - [InputObject](define_input_object.md)
     - [Default value](default_value.md)
+    - [Two ways to define types](procedural_macros.md)
 - [Schema](define_schema.md)
     - [Query and Mutation](query_and_mutation.md)
     - [Subscription](subscription.md)

docs/en/src/procedural_macros.md

@@ -0,0 +1,49 @@
+# Two ways to define types
+
+I think you have discovered that defining a GraphqlQL type can be use attribute macro or derive.
+
+The following is the corresponding table:
+
+|Type|Attribute macro|Derive|
+|---|-----|----|
+|Enum|Enum|GQLEnum|
+|Simple Object|SimpleObject|GQLSimpleObject|
+|Input Object|InputObject|GQLInputObject|
+|Interface|Interface|GQLInterface|
+|Union|Union|GQLUnion|
+|Merged Object|MergedObject|GQLMergedObject|
+|Merged Subscription|MergedSubscription|GQLMergedSubscription|
+
+The advantage of attribute macro is that you can provide some parameters at the same time, for example：
+
+```rust
+#[SimpleObject(name = "ABC")]
+struct MyObject {
+    value: i32,
+}
+```
+
+**But it does not support conditional compilation**, for example:
+
+```rust
+#[SimpleObject]
+struct MyObject {
+    #[cfg(windows)]
+    value: i32,
+
+    #[cfg(not(windows))]
+    value: i32,
+}
+```
+
+**Derive can support conditional compilation**, but it needs to provide parameters separately, for example:
+
+```rust
+#[derive(SimpleObject)]
+#[graphql(name = "ABC")]
+struct MyObject {
+    value: i32,
+}
+```
+
+_Which way to define the type is up to you, I prefer to use derive._

docs/zh-CN/src/SUMMARY.md

@@ -13,6 +13,7 @@
     - [联合(Union)](define_union.md)
     - [输入对象(InputObject)](define_input_object.md)
     - [默认值](default_value.md)
+    - [定义类型的两种方式](procedural_macros.md)
 - [定义模式(Schema)](define_schema.md)
     - [查询和变更](query_and_mutation.md)
     - [订阅](subscription.md)

docs/zh-CN/src/merging_objects.md

@@ -48,3 +48,40 @@ let schema = Schema::new(
     EmptySubscription
 );
 ```
+
+# 合并订阅
+
+和`GQLMergedObject`一样，你可以派生`GQLMergedSubscription`来合并单独的`＃[Subscription]`块。
+
+像合并对象一样，每个订阅块都需要一个唯一的名称。
+
+```rust
+#[derive(Default)]
+struct Subscription1;
+
+#[Subscription]
+impl Subscription1 {
+    async fn events1(&self) -> impl Stream<Item = i32> {
+        futures::stream::iter(0..10)
+    }
+}
+
+#[derive(Default)]
+struct Subscription2;
+
+#[Subscription]
+impl Subscription2 {
+    async fn events2(&self) -> impl Stream<Item = i32> {
+        futures::stream::iter(10..20)
+    }
+}
+
+#[derive(GQLMergedSubscription, Default)]
+struct Subscription(Subscription1, Subscription2);
+
+let schema = Schema::new(
+    Query::default(),
+    EmptyMutation,
+    Subscription::default()
+);
+```

docs/zh-CN/src/procedural_macros.md

@@ -0,0 +1,49 @@
+# 定义类型的两种方式
+
+我想你已经发现，定义一个GraphqlQL类型可以通过属性宏或者派生。
+
+下面是一个对应表：
+
+|类型|属性宏|派生|
+|---|-----|----|
+|枚举(Enum)|Enum|GQLEnum|
+|简单对象(Simple Object)|SimpleObject|GQLSimpleObject|
+|输入对象(Input Object)|InputObject|GQLInputObject|
+|接口(Interface)|Interface|GQLInterface|
+|联合(Union)|Union|GQLUnion|
+|合并对象(Merged Object)|MergedObject|GQLMergedObject|
+|合并订阅(Merged Subscription)|MergedSubscription|GQLMergedSubscription|
+
+属性宏的好处在于你可以同时提供一些参数，例如：
+
+```rust
+#[SimpleObject(name = "ABC")]
+struct MyObject {
+    value: i32,
+}
+```
+
+但是它不支持条件编译，例如：
+
+```rust
+#[SimpleObject]
+struct MyObject {
+    #[cfg(windows)]
+    value: i32,
+
+    #[cfg(not(windows))]
+    value: i32,
+}
+```
+
+派生可以支持条件编译，但它需要单独提供参数，例如：
+
+```rust
+#[derive(SimpleObject)]
+#[graphql(name = "ABC")]
+struct MyObject {
+    value: i32,
+}
+```
+
+用哪种方式来定义类型取决于你，我更加推荐使用派生。