@kwannoel:
This module implements Serde for the Pretty struct. Why not implement it directly on our plan nodes?
That’s because Pretty already summarizes the fields that are important to us.
You can see that when explain() is called, we directly return the Pretty struct.
The proper way to do this would be to create a new data structure that plan nodes get converted into,
and then implement Serialize and Deserialize on that data structure (including to Pretty).
But that’s a lot of refactoring work.
So we just wrap Pretty in a newtype and implement Serialize on that,
since it’s a good enough intermediate representation.
Given a tree-like structure T,
we usually can specify a transformation T -> T
by providing a pre-order transformation pre : T -> T
and a post-order transformation post : T -> T.
Specifically, the derived transformation apply : T -> T first applies pre,
then maps itself over the subtrees, and finally applies post.
This allows us to obtain a global transformation acting recursively on all levels
by specifying simpler transformations at acts locally.
A Layer is a container with subcomponents of type Sub.
We usually use Layer to represents one layer of a tree-like structure,
where the subcomponents are the recursive subtrees.
But in general, the subcomponent can be of different type than the Layer.
Such structural relation between Sub and Layer
allows us to lift transformation on Sub to that on Layer.
A related and even more general notion is Functor,
which might also be helpful to define in the future.