迈向Elixir元编程大师：实战教程引领你的提升

5星 · 超过95%的资源需积分: 10 106 浏览量更新于2024-07-22 1 收藏 4.35MB PDF 举报

《Elixir元编程实践(实用篇,2015)》是一本深入指南，专为想要提升Elixir编程技能，特别是元编程能力的开发者设计。元编程是Elixir的一大亮点，这本书带你逐步探索这一强大的特性，让你能够扩展语言本身，编写更高效、可维护的程序，超越其他语言的限制。本书首先从基础开始，讲解Elixir元编程系统的工作原理，以及宏如何与Elixir的抽象语法结构互动。通过实际操作，你将学会创建自己的第一类功能，比如构建测试框架，理解Elixir如何将源代码视为可组合的模块，而非简单的指令序列。接着，你将学习高级代码生成技术，用极少的代码实现核心库，这展示了Elixir在代码简洁性和效率方面的独特优势。书中还涵盖了领域特定语言（DSL）的创建，帮助你了解何时何地最有效地应用元编程技巧。阅读过程中，作者克里斯·麦考德(Chris McCord)凭借丰富的经验和深入浅出的实例，使读者不仅掌握了元编程技术，还深入了解了Elixir的内部机制。对于新手来说，这本书提供了坚实的基础；对于经验丰富的开发者，它则是一个增强现有技能，充分利用Elixir宏潜力的实用工具。评论者们，如Bruce Tate（RapidRed, LLC的总裁）、Matt Sears（Littlelines的CEO）和Jason Stiebs（RokkinCat的合伙人）都对这本书给出了高度评价，赞扬其优雅的指导方式、丰富的实例以及对Elixir语言工作原理的深刻洞察。Zander Hill（多语言专家）也提到，作者克里斯的独特视角使得这本书超越了技术表面，具有启发性和吸引力。《Metaprogramming Elixir》是一本不可多得的元编程教程，无论你是元编程新手还是资深开发者，都能从中受益匪浅，提升你的Elixir编程技能和项目开发实力。

CHAPTER 1

The Language of Macros

It’s time to begin our journey to metaprogramming mastery. Ahead lies new

Elixir insights and new programming abilities. Perhaps you want to write

more productive libraries, build domain-specific languages, or optimize run-

time performance. Maybe you simply want to have fun exploring all that Elixir

has to offer. If this sounds like you, let’s get started!

By now, you’re familiar with Elixir; you’ve experimented with the language

and perhaps contributed to a library or two. We’re going to take it to the next

level by writing code that writes code with macros. Elixir macros are the game-

changer. They enable metaprogramming and make it a breeze to write powerful

programs.

Code that writes code might sound like a neat trick, but you’ll soon see how

it forms the basis of Elixir’s own construction. Macros open up unique possi-

bilities that simply aren’t possible in most languages. We can extend the

language with powerful first-class features, save time, and share functionality

in fun and productive ways. Used properly, metaprogramming lets us create

clear, concise programs that treat source code as building blocks instead of

as rote lines of instructions.

We’re going to start by covering everything you need to know about Elixir’s

metaprogramming system before we dive into our advanced exercises.

Let’s play.

The World Is Your Playground

Metaprogramming in Elixir is all about extensibility. Have you ever wished

your favorite language would adopt that one neat feature? If you’re lucky, it

might take years to happen. Often it never happens at all. In Elixir, you can

introduce new first-class features at will. Take the familiar

while

loop that you

report erratum • discuss

www.it-ebooks.info

José Valim, the creator of Elixir, chose to do something very different. He

exposed the AST in a form that can be represented by Elixir’s own data

structures and gave us a natural syntax to interact with it. Having the AST

accessible by normal Elixir code lets you do very powerful things because you

can operate at the level typically reserved only for compilers and language

designers. You interact with Elixir’s AST at every step of the metaprogramming

process, so let’s jump in and find out what it’s all about.

Metaprogramming in Elixir revolves around manipulating and inspecting

ASTs. You can access the AST representation of any Elixir expression by using

the quote macro. Code generation relies heavily on

quote

, and we’ll be using

it throughout the book to carry out our exercises. Let’s use it to return the

AST representation of a couple of basic expressions.

Type the following into

iex

and let’s look at the results:

iex> quote do: 1 + 2

{:+, [context: Elixir, import: Kernel], [1, 2]}

iex> quote do: div(10, 2)

{:div, [context: Elixir, import: Kernel], [10, 2]}

We can see that the AST representation of

1 + 2

and

div

produced simple data

structures in Elixir’s own terms. Let that sink in for a moment. You can access

the representation of any code you write as an Elixir data structure. Quoting

expressions gives you something you’ve probably never seen from a language

before: the ability to peer into the internal representation of your code, within

a data structure you already know and understand. This lets you infer

meaning, optimize performance, or extend functionality while staying within

Elixir’s high-level syntax.

With full AST access, we can perform neat tricks during compilation. For

example, the

Logger

module in Elixir’s standard library can optimize logging

by completely removing the expressions from the AST. Let’s say we’re writing

to a file and would like to print the file path in development but ignore the

expression in production. We might write something like the following:

def write(path, contents) do

Logger.debug "Writing contents to file #{path}"

File.write!(path, contents)

end

In production, the

Logger.debug

expression would be completely removed from

the program. This is because we can interact with the AST during compilation

to skip this development-related call. Most languages would have to invoke

report erratum • discuss

The World Is Your Playground • 3

www.it-ebooks.info

You might be wondering what the advantage is of Elixir using macros for its

own constructs, since you get by fine in most languages without this structure.

The most powerful advantage is that macros allow you to extend the language

with your own keywords while using existing macros as building blocks.

The best way to think about metaprogramming in Elixir is to throw away the

notion of rigid keywords and opaque language internals. Elixir was designed

with extension in mind. The language is open to your exploration and custom

features. This is what makes metaprogramming in Elixir so pleasantly natural.

Tying It All Together

We’ve seen how Elixir itself is built with macros and how to use

quote

to return

the AST representation of any expression. Now let’s fit the pieces together.

The most important takeaway is that macros receive ASTs as arguments and

provide ASTs as return values. By writing macros, you are building ASTs

using Elixir’s high-level syntax.

To see this in action, let’s write a macro that can print the spoken form of an

Elixir mathematical expression, such as

5 + 2

, when calculating a result. In

most languages, we would have to parse a string expression into something

digestible by our program. With Elixir, we can access the representation of

expressions directly with macros.

Our first step is to examine the AST structure of some example expressions

that our macro will accept. Let’s head back over to

iex

and quote a few

expressions. Go ahead and try out a few of your own to get a better sense of

the AST’s structure.

iex> quote do: 5 + 2

{:+, [context: Elixir, import: Kernel], [5, 2]}

iex)> quote do: 1 * 2 + 3

{:+, [context: Elixir, import: Kernel],

[{:*, [context: Elixir, import: Kernel], [1, 2]}, 3]}

The AST for

5 + 2

and

1 * 2 + 3

produced a straightforward tuple structure. We

received the atoms

and

representing operators, and the left-hand side

and right-hand side values in the last element. These tuple structures are

the direct representation of their high-level Elixir counterparts.

Now that we know how our expressions are represented, let’s define our first

macro to see how the AST ties in. We’ll define a

Math

module with a

say

macro

that can print any mathematical expression in natural language when calcu-

lating the result.

report erratum • discuss

The World Is Your Playground • 5

www.it-ebooks.info

剩余125页未读，继续阅读

vanridin

粉丝: 108
资源: 1187

迈向Elixir元编程大师：实战教程引领你的提升

Metaprogramming_Elixir

Metaprogramming Ruby 2(Pragmatic,2014)

VS2015编译器设置允许在模版为特化之前使用模版

c++11在编译期间使用模板元编程实现传入一个最小值和个数，生成一个数组

Constant expression required

Validated注解是什么

c++11 auto

qml 报错C4430

typedef 和typedef typename区别

JavaScript groovy关系

最新资源