How to serialize and Deserialize closure?

[TrionProg]

Hello, I am trying to do it.

You wrote:

you either need to specify the precise type you're deserializing without naming it (which is possible but not particularly practical)

How to do it(to deserialize)?

I use serde_traitobject and write this code

use serde_traitobject as st;

let one:usize = 1;
let two:usize = 2;
let plus_one = Fn!(|x: usize| x + one + two);

let s: st::Box<dyn serde_traitobject::Fn(usize) -> usize> = st::Box::new(plus_one);

let serialized = serde_json::to_string(&s).unwrap();
println!("{}",serialized);

let deserialized: st::Box<dyn serde_traitobject::Fn(usize) -> usize> = serde_json::from_str(serialized.as_str()).unwrap();

And I have error: the trait bound `&usize: main::_IMPL_DESERIALIZE_FOR_MyStruct::_serde::Deserialize<'_>` is not satisfied

What should I do?

Can I create struct with two or more closures and serialize and deserialize it? Without Box<dyn ... Fn> just Box<MyStructTrait>?

[alecmocatta]

Hi @TrionProg, thanks for filing an issue!

I think the problem is that the closure here needs to be a move closure to take ownership of the captured variables (one and two), rather than take references to them. This is because it's not possible to deserialize to a reference (your error message shows it's trying to deserialize to a &usize, which isn't possible).

This should work:

let plus_one = Fn!(move |x: usize| x + one + two);

Can I create struct with two or more closures and serialize and deserialize it? Without Box<dyn ... Fn> just Box?

Boxing the closure's trait object, i.e. Box<dyn ... Fn>, is necessary in most use cases. A struct containing multiple closures could look like:

struct MultipleClosures {
    a: Box<dyn st::Fn(usize) -> usize>,
    b: Box<dyn st::Fn(usize) -> usize>,
}

[TrionProg]

Hello. Hm. Yes, I've forgotten move. And now it works.

Unfortunately I need use 2 boxes in the struct, + 1 box for this struct. Later, I hope, I will try to optimize it to MultipleClosures<F1,F2>, this should be simmilar to error_impl in failure library:

Box<Inner<Fail>> 
struct Inner<E:Fail> {
  backtrace
  error:E
}

Thank you for your fantastic library!

[TrionProg]

Hello. Ohh, not all is right. I can not show the code -- it has a lot of garbage and I can not understand anything that happens -- All works, but then I implement Trait, I have a lot of problems like Self: traitobject::Sealed is not satisfied.

Can you give me an example how to: Create trait(MyTrait), that wants Self(MultipleClosures) be serializable (by your library). And Just create MultipleClosures, insert it in Box<dyn MyTrait>and it will serialize and deserialize it. MultipleClosures has one generic as parameter, It should not be stored in this struct, for example, closure a returns it.

[TrionProg]

Okey. I am making experiment. Minimal example of same error.

#![feature(unboxed_closures)]

extern crate serde;
extern crate serde_traitobject;

#[macro_use]
extern crate serde_closure;

#[macro_use]
extern crate serde_derive;

use serde_traitobject::FnOnce as FnOnceTO;
use serde_traitobject::Box as BoxTO;

use serde_traitobject::{
    Serialize as SerializeTO,
    Deserialize as DeserializeTO
};

use serde_derive::{Serialize, Deserialize};

use std::marker::PhantomData;

pub trait BlockTrait: SerializeTO + DeserializeTO{
    fn exec(&mut self) -> bool;
}

#[derive(Serialize, Deserialize)]
struct TwoClosures<T> where
    T:'static
{
    inner: Option<TwoClosuresInner<T>>
}

#[derive(Serialize, Deserialize)]
struct TwoClosuresInner<T> where
    T:'static
{
    #[serde(with = "serde_traitobject")]
    a: Box<FnOnceTO() -> T>,
    #[serde(with = "serde_traitobject")]
    b: Box<FnOnceTO(T) -> bool>,
    _phantom_data:PhantomData<T>
}

impl<T> TwoClosures<T> where
{
    fn new<A, B>(a:A, b:B) -> Self where
        A: FnOnceTO() -> T + 'static,
        B: FnOnceTO(T) -> bool + 'static
    {
        let inner = TwoClosuresInner {
            a: Box::new(a),
            b: Box::new(b),
            _phantom_data: PhantomData
        };

        TwoClosures {
            inner: Some(inner)
        }
    }
}

impl<T> BlockTrait for TwoClosures<T> {
    fn exec(&mut self) -> bool {
        let inner = self.inner.extract();
        let t = (inner.a)();
        (inner.b)(t)
    }
}

fn main() {
    let tc = TwoClosures::new(
        FnOnce!(|| 8usize),
        FnOnce!(move|v|v==8),
    );

    let tc_box:BoxTO<dyn BlockTrait> = BoxTO::new(tc);

    let serialized = serde_json::to_string(&tc_box).unwrap();
    println!("{}",serialized);
}

And errors. It wants T to be serializable, but it is 'static.

error[E0277]: the trait bound `TwoClosures<T>: serde_traitobject::serialize::Sealed` is not satisfied
  --> src\main.rs:67:9
   |
67 | impl<T> BlockTrait for TwoClosures<T> {
   |         ^^^^^^^^^^ the trait `serde_traitobject::serialize::Sealed` is not implemented for `TwoClosures<T>`

error[E0277]: the trait bound `T: serde::Serialize` is not satisfied
  --> src\main.rs:67:9
   |
67 | impl<T> BlockTrait for TwoClosures<T> {
   |      -  ^^^^^^^^^^ the trait `serde::Serialize` is not implemented for `T`
   |      |
   |      help: consider restricting this bound: `T: serde::Serialize`
   |
   = note: required because of the requirements on the impl of `serde::Serialize` for `TwoClosures<T>`
   = note: required because of the requirements on the impl of `serde_traitobject::Serialize` for `TwoClosures<T>`

error[E0277]: the trait bound `T: serde::Deserialize<'_>` is not satisfied
  --> src\main.rs:67:9
   |
67 | impl<T> BlockTrait for TwoClosures<T> {
   |      -  ^^^^^^^^^^ the trait `serde::Deserialize<'_>` is not implemented for `T`
   |      |
   |      help: consider restricting this bound: `T: serde::Deserialize<'_>`
   |
   = note: required because of the requirements on the impl of `for<'de> serde::Deserialize<'de>` for `TwoClosures<T>`
   = note: required because of the requirements on the impl of `serde::de::DeserializeOwned` for `TwoClosures<T>`
   = note: required because of the requirements on the impl of `serde_traitobject::Deserialize` for `TwoClosures<T>`

UPD.

I want to do not haul this 'de, but I try:

pub trait BlockTrait<'de>: Serialize + Deserialize<'de>{
    fn exec(&mut self) -> bool;
}

impl<'de, T> BlockTrait<'de> for TwoClosures<T> {
    fn exec(&mut self) -> bool {
        let inner = self.inner.extract();
        let t = (inner.a)();
        (inner.b)(t)
    }
}

And it wants T:Serialize, T:Deserialize =(

[TrionProg]

And second question: how to serialize struct TwoClosures by may hands without derive?

[alecmocatta]

To make that minimal example work, you need to add #[serde(bound = "")] like this:

#[derive(Serialize, Deserialize)]
#[serde(bound = "")]
struct TwoClosures<T> where
    T:'static
{
    inner: Option<TwoClosuresInner<T>>
}

Without it, serde is generating:

impl<T> Serialize for TwoClosures<T> where T: Serialize { ... }

Though as actually T itself is never serialized, the bound is unnecessary. Adding #[serde(bound = "")] makes serde generate this:

impl<T> Serialize for TwoClosures<T> { ... }

which then enables your program to compile.

[alecmocatta]

And second question: how to serialize struct TwoClosures by may hands without derive?

The serde guide to implementing Serialize and Deserialize are helpful here. The easiest way to serialize/deserialize them manually is as tuples.

[TrionProg]

Hello. Hm.. It works! Thanks.

About Box in structures. What I should to use std::Box or s_to::Box? What is differense? Now it is using std::Box and it works, but maybe I should use s_to::Box. But how I remember I was unable to serialize std::Box manually.

[TrionProg]

Long live to new problems!

My manual serialization worked.

I am adding new generic M

pub trait BlockTrait<M:MyTrait>: SerializeTO + DeserializeTO{
    fn exec(&mut self, m:&mut M) -> bool;
}

pub trait MyTrait {}

struct TwoClosures<T, M> where
    T:'static,
    M:MyTrait + 'static
{
    inner: DataContainer<TwoClosuresInner<T, M>>
}

struct TwoClosuresInner<T, M> where
    T:'static,
    M:MyTrait + 'static
{
    a: BoxTO<FnOnceTO(&mut M) -> T>,
    b: BoxTO<FnOnceTO(T) -> bool>,
}

And I have this problem:

error[E0277]: the trait bound `dyn for<'r> serde_traitobject::FnOnce<(&'r mut M,), Output = T>: serde::Serialize` is not satisfied
   --> src\main.rs:107:32
    |
107 |         s.serialize_field("a", &inner.a)?;
    |                                ^^^^^^^^ the trait `serde::Serialize` is not implemented for `dyn for<'r> serde_traitobject::FnOnce<(&'r mut M,), Output = T>`
    |
    = help: the following implementations were found:
              <(dyn serde_traitobject::FnOnce<Args, Output = Output> + 'static) as serde::Serialize>
              <(dyn serde_traitobject::FnOnce<Args, Output = Output> + std::marker::Send + 'static) as serde::Serialize>
    = note: required because of the requirements on the impl of `serde::Serialize` for `std::boxed::Box<dyn for<'r> serde_traitobject::FnOnce<(&'r mut M,), Output = T>>`

And something about Deser.

The fragment of code:

impl<T,M> Serialize for TwoClosures<T,M> where
    //T:'static,
    M:MyTrait
{
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
        where
            S: Serializer,
    {
        use crate::serde::ser::SerializeStruct;

        let inner = self.inner.get();

        let mut s = serializer.serialize_struct("TwoClosures", 2)?;
        s.serialize_field("a", &inner.a)?;
        s.serialize_field("b", &inner.b)?;
        s.end()
    }
}

It may be solved by using BoxTO instead of Box, but without M it worked! Very strange...

And I want M to be Serial and Deserial -able. How to mark it in trait MyBlock or trait MyTrait ? Note: Other difficult code works by #derive , but I have problems with manual serialization