Simplify arena allocator example

Author: soareschen

crates/cgp-serde-alloc/src/providers/alloc_deserialize.rs

@@ -8,12 +8,12 @@ impl<'de, 'a, Context, Value> ValueDeserializer<'de, &'a Value> for Context
 where
     Context: CanAlloc<'a, Value> + CanDeserializeValue<'de, Value>,
 {
-    fn deserialize<D>(context: &Context, deserializer: D) -> Result<&'a Value, D::Error>
+    fn deserialize<D>(&self, deserializer: D) -> Result<&'a Value, D::Error>
     where
         D: serde::Deserializer<'de>,
     {
-        let value = context.deserialize(deserializer)?;
-        let value = context.alloc(value);
+        let value = self.deserialize(deserializer)?;
+        let value = self.alloc(value);
 
         Ok(value)
     }

crates/cgp-serde-json/src/impls/deserialize.rs

@@ -0,0 +1,19 @@
+use cgp::prelude::*;
+
+use crate::code::DeserializeJson;
+use crate::providers::DeserializeFromJsonString;
+
+pub trait CanDeserializeJsonString<T>: HasErrorType {
+    fn deserialize_json_string(&self, serialized: &str) -> Result<T, Self::Error>;
+}
+
+impl<Context, T> CanDeserializeJsonString<T> for Context
+where
+    Context: HasErrorType,
+    DeserializeFromJsonString:
+        for<'a> TryComputer<Context, DeserializeJson<T>, &'a str, Output = T>,
+{
+    fn deserialize_json_string(&self, serialized: &str) -> Result<T, Self::Error> {
+        <DeserializeFromJsonString>::try_compute(self, PhantomData, &serialized)
+    }
+}

crates/cgp-serde-json/src/impls/mod.rs

@@ -1,7 +1,3 @@
-mod from_reader;
-mod from_str;
-mod to_string;
+mod deserialize;
 
-pub use from_reader::*;
-pub use from_str::*;
-pub use to_string::*;
+pub use deserialize::*;

crates/cgp-serde-json/src/lib.rs

@@ -3,7 +3,5 @@
 extern crate alloc;
 
 pub mod code;
-
-mod impls;
-
-pub use impls::*;
+pub mod impls;
+pub mod providers;

crates/cgp-serde-json/src/impls/from_reader.rs renamed to crates/cgp-serde-json/src/providers/from_reader.rs

@@ -1,25 +1,25 @@
 use cgp::prelude::*;
 use serde_json::de::StrRead;
 
-use crate::DeserializeFromJsonReader;
+use crate::providers::DeserializeFromJsonReader;
 
 pub struct DeserializeFromJsonString<InDeserializer = DeserializeFromJsonReader>(
     pub PhantomData<InDeserializer>,
 );
 
 #[cgp_impl(DeserializeFromJsonString<InDeserializer>)]
-impl<'a, Context, Code, Value, S, InDeserializer> TryComputer<Code, &'a S> for Context
+impl<Context, Code, Value, S, InDeserializer> TryComputer<Code, S> for Context
 where
     Context: HasErrorType,
-    InDeserializer: TryComputer<Context, Code, StrRead<'a>, Output = Value>,
+    InDeserializer: for<'a> TryComputer<Context, Code, StrRead<'a>, Output = Value>,
     S: AsRef<str>,
 {
     type Output = Value;
 
     fn try_compute(
         context: &Context,
         code: PhantomData<Code>,
-        source: &'a S,
+        source: S,
     ) -> Result<Value, Context::Error> {
         InDeserializer::try_compute(context, code, StrRead::new(source.as_ref()))
     }

crates/cgp-serde-json/src/impls/from_str.rs renamed to crates/cgp-serde-json/src/providers/from_str.rs

@@ -0,0 +1,7 @@
+mod from_reader;
+mod from_str;
+mod to_string;
+
+pub use from_reader::*;
+pub use from_str::*;
+pub use to_string::*;

crates/cgp-serde-json/src/providers/mod.rs

@@ -1,13 +1,13 @@
 use cgp::core::error::{ErrorRaiserComponent, ErrorTypeProviderComponent};
-use cgp::extra::handler::CanTryCompute;
 use cgp::prelude::*;
 use cgp_error_anyhow::{RaiseAnyhowError, UseAnyhowError};
 use cgp_serde::components::ValueDeserializerComponent;
 use cgp_serde::providers::{DeserializeExtend, DeserializeRecordFields, UseSerde};
 use cgp_serde_alloc::providers::DeserializeAndAllocate;
 use cgp_serde_alloc::traits::AllocatorComponent;
 use cgp_serde_json::code::{DeserializeJson, SerializeJson};
-use cgp_serde_json::{DeserializeFromJsonString, SerializeToJsonString};
+use cgp_serde_json::impls::CanDeserializeJsonString;
+use cgp_serde_json::providers::{DeserializeFromJsonString, SerializeToJsonString};
 use cgp_serde_typed_arena::providers::AllocateWithArena;
 use cgp_serde_typed_arena::traits::ArenaGetterComponent;
 use typed_arena::Arena;
@@ -43,14 +43,15 @@ delegate_components! {
         ValueDeserializerComponent:
             UseDelegate<new DeserializeComponents {
                 u64: UseSerde,
-                Coord:
+                [
+                    Coord,
+                    <'a> Payload<'a>,
+                ]:
                     DeserializeRecordFields,
                 <'a> &'a Coord:
                     DeserializeAndAllocate,
                 <'a> Vec<&'a Coord>:
                     DeserializeExtend,
-                <'a> Payload<'a>:
-                    DeserializeRecordFields,
 
             }>,
         TryComputerComponent:
@@ -97,9 +98,8 @@ fn test_deserialize_with_arena() {
     let arena = Arena::new();
     let app = App { arena: &arena };
 
-    let deserialized: Payload<'_> = app
-        .try_compute(PhantomData::<DeserializeJson<Payload<'_>>>, &serialized)
-        .unwrap();
+    let deserialized: Payload<'_> = app.deserialize_json_string(&serialized).unwrap();
+
     assert_eq!(
         deserialized,
         Payload {

crates/cgp-serde-json/src/impls/to_string.rs renamed to crates/cgp-serde-json/src/providers/to_string.rs

@@ -1,11 +1,9 @@
 use cgp::core::error::{ErrorRaiserComponent, ErrorTypeProviderComponent};
-use cgp::extra::handler::CanTryCompute;
 use cgp::prelude::*;
 use cgp_error_anyhow::{RaiseAnyhowError, UseAnyhowError};
 use cgp_serde::components::{CanDeserializeValue, ValueDeserializer, ValueDeserializerComponent};
 use cgp_serde::providers::{DeserializeExtend, DeserializeRecordFields, UseSerde};
-use cgp_serde_json::code::{DeserializeJson, SerializeJson};
-use cgp_serde_json::{DeserializeFromJsonString, SerializeToJsonString};
+use cgp_serde_json::impls::CanDeserializeJsonString;
 use typed_arena::Arena;
 
 #[cgp_auto_getter]
@@ -18,26 +16,26 @@ impl<'de, 'a, Context, Value> ValueDeserializer<'de, &'a Value> for Context
 where
     Context: HasArena<'a, Value> + CanDeserializeValue<'de, Value>,
 {
-    fn deserialize<D>(context: &Context, deserializer: D) -> Result<&'a Value, D::Error>
+    fn deserialize<D>(&self, deserializer: D) -> Result<&'a Value, D::Error>
     where
         D: serde::Deserializer<'de>,
     {
-        let value = context.deserialize(deserializer)?;
-        let value = context.arena().alloc(value);
+        let value = self.deserialize(deserializer)?;
+        let value = self.arena().alloc(value);
 
         Ok(value)
     }
 }
 
-#[derive(Debug, PartialEq, Eq, HasFields, BuildField)]
+#[derive(Debug, PartialEq, Eq, CgpData)]
 pub struct Coord {
     pub x: u64,
     pub y: u64,
     pub z: u64,
 }
 
-#[derive(Debug, PartialEq, Eq, HasFields, BuildField)]
-pub struct Payload<'a> {
+#[derive(Debug, PartialEq, Eq, CgpData)]
+pub struct Cluster<'a> {
     pub id: u64,
     pub coords: Vec<&'a Coord>,
 }
@@ -48,31 +46,25 @@ pub struct App<'a> {
 }
 
 delegate_components! {
-    <'a> App<'a> {
-        ErrorTypeProviderComponent:
-            UseAnyhowError,
-        ErrorRaiserComponent:
-            RaiseAnyhowError,
+    <'s> App<'s> {
         ValueDeserializerComponent:
             UseDelegate<new DeserializeComponents {
                 u64: UseSerde,
-                Coord:
+                [
+                    Coord,
+                    <'a> Cluster<'a>,
+                ]:
                     DeserializeRecordFields,
                 <'a> &'a Coord:
                     DeserializeAndAllocate,
                 <'a> Vec<&'a Coord>:
                     DeserializeExtend,
-                <'a> Payload<'a>:
-                    DeserializeRecordFields,
 
             }>,
-        TryComputerComponent:
-            UseDelegate<new JsonEncodingComponents {
-                SerializeJson:
-                    SerializeToJsonString,
-                <T> DeserializeJson<T>:
-                    DeserializeFromJsonString
-            }>,
+        ErrorTypeProviderComponent:
+            UseAnyhowError,
+        ErrorRaiserComponent:
+            RaiseAnyhowError,
     }
 }
 
@@ -90,7 +82,7 @@ check_components! {
             (Life<'de>, u64),
             (Life<'de>, Coord),
             (Life<'de>, &'a Coord),
-            (Life<'de>, Payload<'a>),
+            (Life<'de>, Cluster<'a>),
         ]
     }
 }
@@ -110,12 +102,11 @@ fn test_deserialize_with_arena() {
     let arena = Arena::new();
     let app = App { arena: &arena };
 
-    let deserialized: Payload<'_> = app
-        .try_compute(PhantomData::<DeserializeJson<Payload<'_>>>, &serialized)
-        .unwrap();
+    let deserialized: Cluster<'_> = app.deserialize_json_string(&serialized).unwrap();
+
     assert_eq!(
         deserialized,
-        Payload {
+        Cluster {
             id: 8,
             coords: vec![&Coord { x: 1, y: 2, z: 3 }, &Coord { x: 4, y: 5, z: 6 },]
         }