Metaprogramming

https://en.wikipedia.org/wiki/Metaprogramming

愿编程， 是一中编程技术， 制造的计算机程序，具有能力， 对待程序为他们的数据。

针对程语言的编程技术。

Metaprogramming is a programming technique in which computer programs have the ability to treat programs as their data. It means that a program can be designed to read, generate, analyse or transform other programs, and even modify itself while running.^[1][2] In some cases, this allows programmers to minimize the number of lines of code to express a solution, thus reducing the development time.^[3] It also allows programs greater flexibility to efficiently handle new situations without recompilation.

Metaprogramming can be used to move computations from run-time to compile-time, to generate code using compile time computations, and to enable self-modifying code. The language in which the metaprogram is written is called the metalanguage. The language of the programs that are manipulated is called the attribute-oriented programming language. The ability of a programming language to be its own metalanguage is called reflection or "reflexivity".^[4] Reflection is a valuable language feature to facilitate metaprogramming.

Metaprogramming was popular in the 1970s and 1980s using list processing languages such as LISP. LISP hardware machines were popular in the 1980s and enabled applications that could process code. They were frequently used for artificial intelligence applications.

例子

A simple example of a metaprogram is this POSIX Shell script, which is an example of generative programming:

#!/bin/sh
# metaprogram
echo ‘#!/bin/sh‘ > program
for i in $(seq 992)
do
    echo "echo $i" >> program
done
chmod +x program

Uses in programming languages

Macro systems

• Scheme hygienic macros
• MacroML
• Template Haskell
• Scala macros

Metaclasses

Metaclasses are provided by the following programming languages:

• Python
• Nil
• Groovy
• Ruby

Template metaprogramming

Main article: Template metaprogramming

• C "X Macros"
• C++ Templates
• D

Staged metaprogramming

• MetaML
• MetaOCaml
• Scala using the Lightweight Modular Staging Framework^[10][11]

With dependent types

• Usage of dependent types allows proving that generated code is never invalid.^[12] However, this approach is bleeding-edge and is rarely found outside of research programming languages.

以此理解： C预处理、 lex yacc解析脚本程序 ， 都是针对语言的编程。

Lua Macros

http://lua-users.org/wiki/LuaMacros

Implementing List Comprehensions

In PythonLists, FabienFleutot discusses a list comprehension syntax modelled on the Python one.

x = {i for i = 1,5}

{1,2,3,4,5}

Such a statement does not actually require much transformation to be valid Lua. We use anonymous functions:

x = (function() local ls={}; for i = 1,5 do ls[#ls+1] = i end; return ls end)()

However, to make it work as a macro, we need to choose a name (here ‘L‘) since we cannot look ahead to see the `for` token.

macro.define(‘L‘,{‘expr‘,‘loop_part‘,handle_parms=true},
    ‘ ((function() local t = {}; for loop_part do t[#t+1] = expr end; return t end)()) ‘,
    function(ls)
        local get = ls.getter
        local line,t = get()
        if t ~= ‘{‘ then macro.error("syntax: L{<expr> for <loop-part>}") end
        local expr = macro.grab_parameters(‘for‘)
        local loop_part = macro.grab_parameters(‘}‘,‘‘)
        return expr,loop_part
    end)

The substitution is pretty straightforward, but we have grab the parameters with a custom function. The first call to macro.grab_parameters grabs upto ‘for‘, and the second grabs upto ‘}‘. Here we have to be careful that commas are not treated as delimiters for this grab by setting the second argument to be the empty string.

Any valid for-loop part can be used:

 L{{k,v} for k,v in pairs{one=1,two=2}}

 { "one", 1 }, { "two", 2 } }

Nested comprehensions work as expected:

x = L{L{i+j for j=1,3} for i=1,3}

{ { 2, 3, 4 }, { 3, 4, 5 }, { 4, 5, 6 } }

A particularly cool idiom is to grab the whole of standard input as a list, in one line:

lines = L{line for line in io.lines()}

原文地址：https://www.cnblogs.com/lightsong/p/8491132.html