Hi, readers,
Here is a pipeline that generates some output from a D (language) program and passes it to a Python program that converts that output to PDF. The D program makes use of a bit of (simple) template programming / generics and a bit of functional programming (using the std.functional module from Phobos, D's standard library).
D => Python
I'm showing this as yet another example of the uses of xtopdf, my Python toolkit for PDF creation, as well as for the D part, which is fun (pun intended :), and because those D features are powerful.
The D program is derived, with some modifications, from a program in this post by Gary Willoughby,
More hidden treasure in the D standard library .
That program demonstrates, among other things, the pipe feature of D from the std.functional module.
First, the D program, student_grades.d:
/*
student_grades.d
Author: Vasudev Ram
Web site: https://vasudevram.github.io
Blog: http://jugad2.blogspot.com
Product store: https://gumroad.com/vasudevram
Adapts code from:
http://nomad.so/2015/08/more-hidden-treasure-in-the-d-standard-library/
*/
import std.stdio;
import std.algorithm;
import std.array;
import std.conv;
import std.functional;
// Set up the functional pipeline by composing some functions.
alias sumString = pipe!(split, map!(to!(int)), sum);
void main(string[] args)
{
// Data to be transformed:
// Each string has the student name followed by
// their grade in 5 subjects.
auto student_grades_list =
[
"A 1 2 3 4 5",
"B 2 3 4 5 6",
"C 3 4 5 6 7",
"D 4 5 6 7 8",
"E 5 6 7 8 9",
];
// Transform the data for each student.
foreach(student_grades; student_grades_list) {
auto student = student_grades[0]; // name
auto total = sumString(student_grades[2..$]); // grade total
writeln("Grade total for student ", student, ": ", total);
}
}
The initial data (which the D program transforms) is hard-coded, but that can easily be changed to read it from a text file, for instance. The program uses pipe() to compose [1] the functions split, map (to int), and sum (some of which are generic / template functions).So, when it is run, each string (student_grades) of the input array student_grades_list is split (into an array of smaller strings, by space as the delimiter); then each string in the array (except for the first, which is the name), is mapped (converted) to integer; then all the integers are summed up to get the student's grade total; finally these names and totals are written to standard output. That becomes the input to the next stage of the pipeline, the Python program, which does the conversion to PDF.
Build the D program with:
dmd -o- student_grades.dwhich gives us the executable, student_grades(.exe).
The Python part of the pipeline is StdinToPDF.py, one of the apps in the xtopdf toolkit, which is designed to be used in pipelines such as the above - basically, any Unix, Windows or Mac OS X pipeline, that generates text as its final output, can be further terminated by StdinToPDF, resulting in conversion of that text to PDF. It is a small Python app written using the core class of the xtopdf library, PDFWriter. Here is the original post about StdinToPDF:
[xtopdf] PDFWriter can create PDF from standard input
Here is the pipeline:
$ student_grades | python StdinToPDF.py sg.pdf
Below is a cropped screenshot of the generated output, sg.pdf, as seen in Foxit PDF Reader.
[1] Speaking of functional composition, you may like to check out this earlier post by me:
fmap(), "inverse" of Python map() function
It's about a different way of composing functions (for certain cases). It also has an interesting comment exchange between me and a reader, who showed both how to do it in Scala, and another way to do it in Python. Also, there is another way to compose functions in D, using a function called compose; it works like pipe, but the composed functions are written in the reverse order. It's in the same D module as pipe, std.functional.
Finally (before I pipe down - for today :), check out this HN comment by me (on another topic), in which I mention and link to multiple other ways of doing pipe-like stuff in Python:
Comment on Streem – a new programming language from Matz
- Enjoy.
- Vasudev Ram - Online Python training and consulting Get updates on my software products / ebooks / courses. Jump to posts: Python DLang xtopdf Subscribe to my blog by email My ActiveState recipes
