Elixir – Ngôn ngữ được viết bằng macros

275

Bài viết được sự cho phép của tác giả Huỳnh Quán Cẩm

  "Bách khoa toàn thư" ngôn ngữ lập trình Perl
  10 ngôn ngữ phát triển nhanh nhất theo GitHub thống kê năm 2019

Viết tiếp một bài viết

Trong bài viết Elixir/Erlang, Actors model và Concurrency, tui có giới thiệu về cách mà Erlang/OTP có thể giúp người dùng xây dựng một concurrent, distributed và fault tolerance system. Nếu bạn chưa đọc bài viết đó, tui sẽ đề nghị bạn vào bấm like ngay. Bởi vì bài viết này không có gì liên quan tới bài viết đó cả .

Tình hình là sau bài viết đó, một số bạn chưa bấm like nhưng đặt câu hỏi rất nhiệt tình, rằng: “Ừa nếu Erlang/OTP tốt thế, sao không dùng Erlang thôi mà dùng Elixir chi cho mắc mệt vậy?”.

Một số lý do có thể khiến bạn cân nhắc Elixir thay vì Erlang. Elixir có bộ standard library nhất quán hơn Erlang, có Mix là build tool cung cấp các tác vụ để tạo, compile project, và quản lý dependencies. Ngoài ra, các module như Protocol, Struct, Stream, ExUnit giúp cho việc lập trình dễ dàng. Documentation được xem như first class citizen trong ngôn ngữ, lập trình viên Elixir được khuyến khích viết và maintain docs, với các công cụ như doctest. Ngoài ra, theo ý kiến chủ quan của tui, code Elixir dễ đọc và dễ học hơn nhiều, so với code nhìn như đám rừng của Erlang .

Cơ mà trên tất cả, một lần nữa theo ý kiến chủ quan của tui , metaprogramming là một tính năng bạn không nên bỏ qua khi cân nhắc Elixir. Nhờ có metaprogramming, Elixir có những thư viện với DSL đẹp như Ecto, Phoenix, Nerves. Nhờ metaprogramming, bạn có thể tự viết compiler của riêng mình như một stage trong quá trình biên dịch. Nhờ metaprogramming, một thư viện đã được tăng tốc chỉ với vài dòng code.

Metaprogramming Elixir

Như bạn đã biết, meta-programming là một kỹ thuật dùng code để viết code. Nắm vững kĩ thuật meta-programming trong Elixir như đã nói có thể giúp bạn tận dụng compile time để nâng cao performance, viết DSL và làm nhiều trò vui khác.

Mặc dầu hướng dẫn meta-programming không phải là mục tiêu của bài viết này, tui vẫn sẽ nói sơ qua về định nghĩa và cách sử dụng một số construct như quoteunquote, và macros để bạn meta-program trong Elixir. Bạn có thể đọc tutorial trên trang chủ Elixir nếu muốn tìm hiểu chi tiết hơn.

quote và unquote

Meta-programming trong Elixir được thực hiện thông qua hai construct là quote và unquote.

quote trả về AST (Abstract Syntax Tree) của biểu thức nhận vào. Một AST trong Elixir là một tuple gồm ba phần tử: tên của AST, metadata chứa environment của AST, và các tham số của AST đó.

quote do
  sum(max(1, 2), 3)
end

# {:sum, [], [
#   {:max, [], [1, 2]},
#   3
# ]}

Trong khi đó unquote cho phép bạn inject một value bên ngoài vào biểu thức trong quote. Hãy tưởng tượng unquote như string interpolation, khác với interpolation là giá trị của biến được chèn vào chuỗi, unquote cho phép bạn chèn giá trị của biến vào một biểu thức trong quote.

a = max(1, 2) # => 2

quote do
  sum(unquote(a), 3)
end

# {:sum, [], [2, 3]}

Chú ý một biến ở ngoài quote không ảnh hưởng đến biểu thức bên trong nó, trừ phi bạn unquote biến đó một cách tường minh. Ví dụ sau đây, thay vì chèn 3 vào AST như ví dụ ở trên, {:a, [], Elixir} đại diện cho biến a được chèn vào trong AST trả về.

a = max(1, 2)

quote do
  sum(a, 3)
end

# {:sum, [], [{:a, [], Elixir}, 3]}

Với quote và unquote, bạn đã đủ đồ chơi để bắt đầu meta-program một ứng dụng Elixir. Mặc dù vậy, bạn cần thêm sự trợ giúp của macros.

Macros

Macros là một trong những viên gạch giúp bạn metaprogram trên nền tảng ngôn ngữ Elixir. Macros trong Elixir là hygienic, lexical, và explicit. Mặc định biến định nghĩa trong macros không ảnh hưởng đến code của caller; muốn dùng macros của một module, bạn phải require hoặc import module đó tường minh, và không có chuyện tự động import một module ở mức global (nhắc đến thì cơn đau đầu của tui với Ruby lại tràn về); cuối cùng là bạn không thể chạy một macro mà không gọi nó.

Để khai báo một macros, bạn dùng defmacro. Chú ý macros phải được khai báo trong một module. Ở ví dụ sau, macro HelloWorld.define_hello_world() giúp bạn định nghĩa hàm hello_world/0 trong Foo mà không cần phải viết toàn bộ hàm.

defmodule HelloWorld do
  defmacro define_hello_world() do
    quote do
      def hello_world() do
        IO.puts("hello world")
      end
    end
  end
end

defmodule Foo do
  import HelloWorld

  define_hello_world()
end

Foo.hello_world()
# hello world

Elixir – Ngôn ngữ được viết bằng macros

Thật vậy, không ngoa khi nói Elixir là một ngôn ngữ được viết bằng macros của chính nó.

Ngoài một số construct được định nghĩa dưới dạng special forms được ngôn ngữ bảo vệ, tất cả mọi hàm và macros khác của Elixir, bạn đều có thể override lại được, kể cả biểu thức và “keyword” ifindefdefmodule, hay thậm chí là cả … defmacro nữa.

Để chứng minh tui không chém gió, ta hãy cùng đọc code của if được định nghĩa trong Kernel.

defmacro if(condition, clauses) do
  build_if(condition, clauses)
end

defp build_if(condition, do: do_clause) do
  build_if(condition, do: do_clause, else: nil)
end

defp build_if(condition, do: do_clause, else: else_clause) do
  optimize_boolean(
    quote do
      case unquote(condition) do
        x when :"Elixir.Kernel".in(x, [false, nil]) -> unquote(else_clause)
        _ -> unquote(do_clause)
      end
    end
  )
end

defp build_if(_condition, _arguments) do
  raise ArgumentError,
        "invalid or duplicate keys for if, only "do" and an optional "else" are permitted"
end

Như ta thấy, về bản chất if chỉ là một macro viết lại biểu thức truyền vào thành một mệnh đề sử dụng case (là một special form). Nếu condition trả về có giá trị là false hoặc nil, mệnh đề else sẽ được thực hiện; ngược lại, mệnh đề do sẽ được thực hiện.

Tương tự với unless, nó chỉ là đảo ngược lại của if.

defp build_unless(condition, do: do_clause, else: else_clause) do
  quote do
    if(unquote(condition), do: unquote(else_clause), else: unquote(do_clause))
  end
end

Cả &&||or và and cũng không phải là special forms mà chỉ là macros .

defmacro left && right do
  assert_no_match_or_guard_scope(__CALLER__.context, "&&")

  quote do
    case unquote(left) do
      x when :"Elixir.Kernel".in(x, [false, nil]) ->
        x

      _ ->
        unquote(right)
    end
  end
end

Thật tuyệt vời khi một ngôn ngữ có thể tự viết chính nó chỉ bằng một số special form ban đầu đúng không? Với các special forms này, bạn có thể tự viết lại phiên bản if của riêng mình. Ví dụ, ta sẽ viết lại if với điều kiện nghiêm ngặt hơn: chỉ chấp nhận boolean condition.

# lib/sane_if.ex

defmodule SaneIf do
  defmacro if(condition, do: do_clause, else: else_clause) do
    quote do
      case unquote(condition) do
        true -> unquote(do_clause)
        false -> unquote(else_clause)
        _other -> raise ArgumentError, "This is a sane macro that only works with boolean"
      end
    end
  end
end

# lib/use_sane_if.ex

import Kernel, except: [if: 2]

defmodule UseSaneIf do
  import SaneIf

  def sane?(a) do
    if a do
      "sane"
    else
      "insane"
    end
  end
end

# iex(1)> UseSaneIf.sane?(true)
# "sane"
# iex(2)> UseSaneIf.sane?(false)
# "insane"
# iex(3)> UseSaneIf.sane?(is_number(3))
# "sane"
# iex(4)> UseSaneIf.sane?(nil)
# ** (ArgumentError) This is a sane macro that only works with boolean

Làm thế nào để Elixir làm được điều này? Tất cả là nhờ vào expansion stage trong quá trình compile, tui sẽ viết rõ hơn trong một bài viết khác .

Bài viết này sẽ giúp bạn tăng lương thế nào?

Như thường lệ, bài viết không giúp bạn tăng lương.

Nếu bạn vừa tiếp cận với Elixir, tui hy vọng bài viết đã giúp bạn hiểu rõ hơn một chút về ngôn ngữ này, về cách mà nó đã dùng macro để tạo nên ngôn ngữ.

Nhân bài viết về macros trong Elixir, tui muốn nhắc lại là mỗi khi bạn định viết một macro nào đó, hãy nhớ rằng … bạn KHÔNG CẦN phải viết macros. Macros thường làm code của của bạn khó đọc hơn và ảo diệu hơn, mà cái gì mà ảo diệu hơn thì thường khó maintain hơn.

Hay nói rõ hơn là hầu như bạn không cần đến macros trừ phi bạn có một lý do thật sự mạnh mẽ. Lý do DRY code (Don’t Repeat Yourself) thường là không đủ thuyết phục. Bạn có behaviours, protocols, đủ để bạn DRY code mà không cần đến macro.

Ngay trên trang chủ, core team của Elixir đã viết:

Elixir already provides mechanisms to write your everyday code in a simple and readable fashion by using its data structures and functions. Macros should only be used as a last resort. Remember that explicit is better than implicit. Clear code is better than concise code.

Bài viết gốc được đăng tải tại quan-cam.com

Có thể bạn quan tâm:

Xem thêm các việc làm Developer hấp dẫn tại TopDev

Báo cáo bài viết vi phạm bản quyền>>