In the previous chapter, we looked at .NET reflection as a way to do metaprogramming: analyzing static type information to reason about program code. While metaprogramming using reflection can do things like load program plug-ins, if you want to reason about how that code operates, you are out of luck. The .NET reflection APIs allow you to get at the raw MSIL op codes, but you have to reverse engineer what that code does—a daunting task at best.
However, there are many applications where knowing not only the structure of program code but also how it operates can be beneficial: for example, taking a function written in F# and converting it into a form that can execute on a graphics card’s GPU. (Presumably to be executed much, much faster.)
F# provides a mechanism called
expressions by which you can access not only the static type
information for a block of code, but also see how the code is structured—that is, the F# compiler’s internal
representation (sometimes referred to as an
abstract syntax tree, or AST).
Using F# quotations, you can:
Perform code analysis and inspection
Defer computation to other platforms (SQL, GPU, and so on)
Generate new code
We will look at these capabilities shortly, but first let’s look at how we can get started with this language feature. Quotations are deep wizardry though, and not for the faint of heart. This chapter only provides a crash course on the subject. To truly master quotations, refer to online resources at the ...