Many parts of the Agg & path processing pipeline work by constructingnested templated objects that represent steps of the processingpipeline, e.g. (simplified example)```agg::conv_transform<mpl::PathIterator>  // The processing step.    tpath  // The name of the result.        (path, trans);  // The arguments passed to the processing step.PathNanRemover<agg::conv_transform<mpl::PathIterator>>    nan_removed        (tpath, true, path.has_codes());```The current implementation makes the code shorter by introducing aliastypenames for the types at each intermediate step.As of C++17, this can be made simpler and shorter because class templateargument deduction ("CTAD") allows not specifying the template arguments(in angle brackets) anymore, i.e. one can write```agg::conv_transform tpath(path, trans);PathNanRemover nan_removed(tpath, true, path.has_codes());```and the compiler will auto-fill in the required types.Furthermore, because these steps can be seen as a pipeline (even thoughthey are implemented as the construction of nested objects), it may feelmore natural to write them as repeated "function" (constructor)application, i.e.```auto tpath = agg::conv_transform{path, trans};auto nan_removed = PathNanRemover{tpath, true, path.has_codes()};```Perform this transformation whereever applicable.