0Pricing
Elixir & Phoenix: Scalable Backend Development · レッスン

再帰と高階関数

関数型プログラミングの基本概念として再帰を理解し、動作を抽象化する高階関数について学びます。

「再帰と高階関数」はCoddyKit上の無料Elixir & Phoenix: Scalable Backend Developmentレッスンです。 これはレッスン3/4です。 下記で完全なレッスンを無料で読むことができます。その後、ブラウザ内の組み込みコードエディタと24時間対応のAIチューターでハンズオン演習できます。 これはElixir & Phoenix: Scalable Backend Development学習パスの一部であり、ウェブとCoddyKitアプリ全体で進捗が同期されます。 Elixir & Phoenix: Scalable Backend Developmentコースには全4レッスンが含まれています。

このレッスンの一部はまだ翻訳されておらず、英語で表示されています。

Meet Recursion in Elixir

Welcome to recursion! In functional programming, recursion is a powerful technique where a function calls itself to solve a problem.

Instead of using loops (like for or while in other languages), Elixir often relies on recursion to iterate over data or repeat actions. It's a core concept you'll use a lot!

The Two Pillars of Recursion

Every recursive function needs two main parts to work correctly:

  • Base Case: This is the stopping condition. It defines when the function should stop calling itself and return a direct result. Without it, your function would run forever!
  • Recursive Step: This is where the function calls itself again, but with a smaller or simpler version of the original problem. Each call moves closer to the base case.

Recursion in Action: Factorial

Let's see recursion with a classic example: calculating the factorial of a number. The factorial of n (written as n!) is the product of all positive integers less than or equal to n. For example, 5! = 5 * 4 * 3 * 2 * 1 = 120.

Notice how factorial(n) calls factorial(n - 1) until it hits the base case of 0.

defmodule Math do
  def factorial(0), do: 1
  def factorial(n) when n > 0, do: n * factorial(n - 1)
end

IO.puts "Factorial of 5: #{Math.factorial(5)}"

Efficient Recursion: Tail Calls

While recursion is great, naive recursion can sometimes lead to performance issues or 'stack overflows' for very deep calls.

Elixir (and the Erlang VM) offers Tail Call Optimization (TCO). If the recursive call is the very last operation in a function, the VM can optimize it, preventing new stack frames from being created. This makes tail-recursive functions as efficient as loops!

Optimizing with Tail Recursion

To achieve TCO, we often use an accumulator. This is an extra argument passed to the function that collects the result as the recursion progresses.

Compare this version to the previous one. The recursive call factorial(n - 1, n * acc) is the last thing happening in the function, making it tail-recursive.

defmodule Math do
  # Public interface, calls the private tail-recursive function
  def factorial(n), do: factorial(n, 1)

  # Private tail-recursive function with accumulator
  defp factorial(0, acc), do: acc
  defp factorial(n, acc) when n > 0, do: factorial(n - 1, n * acc)
end

IO.puts "Tail factorial of 5: #{Math.factorial(5)}"

Functions as First-Class Citizens

Now, let's explore Higher-Order Functions (HOFs). In Elixir, functions are 'first-class citizens'. This means you can:

  • Pass functions as arguments to other functions.
  • Return functions as results from other functions.
  • Assign functions to variables.

HOFs enable powerful abstractions, making your code more concise, flexible, and reusable.

Transforming Lists with Enum.map

Enum.map/2 is one of the most common HOFs. It takes an enumerable (like a list) and a function. It applies that function to each element and returns a new list with the transformed elements.

It never modifies the original list, embracing Elixir's immutability.

numbers = [1, 2, 3, 4]
doubled_numbers = Enum.map(numbers, fn n -> n * 2 end)

IO.puts "Original: #{inspect numbers}"
IO.puts "Doubled: #{inspect doubled_numbers}"

Filtering Lists with Enum.filter

Another handy HOF is Enum.filter/2. It takes an enumerable and a function that should return a boolean (true or false).

It returns a new list containing only the elements for which the function returned true. It's perfect for selecting specific items from a collection.

numbers = [1, 2, 3, 4, 5, 6]
even_numbers = Enum.filter(numbers, fn n -> rem(n, 2) == 0 end)

IO.puts "Original: #{inspect numbers}"
IO.puts "Even: #{inspect even_numbers}"

Aggregating with Enum.reduce

Enum.reduce/3 is perhaps the most powerful HOF for working with enumerables. It takes an enumerable, an initial accumulator value, and a function.

It iterates through the collection, applying the function to each element and the current accumulator, eventually reducing the entire collection to a single value.

numbers = [1, 2, 3, 4]
sum = Enum.reduce(numbers, 0, fn n, acc -> n + acc end)
product = Enum.reduce(numbers, 1, fn n, acc -> n * acc end)

IO.puts "Numbers: #{inspect numbers}"
IO.puts "Sum: #{sum}"
IO.puts "Product: #{product}"

Anonymous Functions and HOFs

You've seen fn n -> n * 2 end. These are anonymous functions (or lambdas). Elixir provides a shorthand for simple anonymous functions:

  • &1 refers to the first argument.
  • &2 refers to the second argument, and so on.
  • &(&1 + &2) is equivalent to fn a, b -> a + b end.

This makes HOF calls even more concise!

numbers = [1, 2, 3, 4]
doubled_short = Enum.map(numbers, &(&1 * 2))
even_short = Enum.filter(numbers, &(rem(&1, 2) == 0))

IO.puts "Doubled (short): #{inspect doubled_short}"
IO.puts "Even (short): #{inspect even_short}"

Test Your HOF Knowledge

Higher-Order Functions are a cornerstone of functional programming in Elixir. Let's check your understanding.

Recursion & HOFs: Key Takeaways

Great job! In this lesson, you've grasped two fundamental concepts in functional Elixir:

  • Recursion: A function calling itself, defined by a base case and a recursive step.
  • Tail Call Optimization (TCO): An important Elixir feature for efficient, stack-safe recursion, often achieved with an accumulator.
  • Higher-Order Functions (HOFs): Functions that take other functions as arguments or return them, like Enum.map, Enum.filter, and Enum.reduce.
  • Anonymous Functions: Concise ways to define functions inline, often used with HOFs, including the &1 shorthand.

These tools are essential for writing expressive and powerful Elixir code. Keep practicing!

よくある質問

「再帰と高階関数」レッスンは無料ですか？

はい。「再帰と高階関数」の完全なテキストはこのウェブで無料で読めます。インタラクティブに演習し（組み込みコードエディタと24時間対応のAIチューター）、Elixir & Phoenix: Scalable Backend Developmentコースの残りをアンロックするには、CoddyKit PROにアップグレードしてください。 Elixir & Phoenix: Scalable Backend Developmentコースには全4レッスンが含まれています。

「再帰と高階関数」で何を学びますか？

関数型プログラミングの基本概念として再帰を理解し、動作を抽象化する高階関数について学びます。 ブラウザで直接実行するハンズオンコードでElixir & Phoenix: Scalable Backend Developmentを演習し、24時間対応のAIチューターがレッスンを進める中での質問に答えます。

Elixir & Phoenix: Scalable Backend Developmentを始めるのに経験は必要ですか？

事前経験は必要ありません。CoddyKitのElixir & Phoenix: Scalable Backend Developmentは初級者から上級者向けに構成されているため、ここから始めるか最初から始めて、自分のペースで進むことができます。 これはレッスン3/4です。

「再帰と高階関数」レッスンにはどのくらい時間がかかりますか？

ほとんどのCoddyKitレッスンは約5～10分かかります。各レッスンはコンパクトでインタラクティブなので、着実に進歩し、ウェブとアプリ全体で正確に前回の場所から再開できます。

このElixir & Phoenix: Scalable Backend Developmentレッスンでコードを書いて実行できますか？

はい。すべてのElixir & Phoenix: Scalable Backend Developmentレッスンに組み込みコードエディタが含まれているため、ブラウザでリアルコードを書いて実行し、即座のAIフィードバックを取得できます。ローカル設定は不要です。

このコースのすべてのレッスン

  1. 関数、モジュール、パイプライン
  2. Enumerableコレクションの操作
  3. 再帰と高階関数
  4. Streamモジュールによる遅延評価
← Elixir & Phoenix: Scalable Backend Developmentに戻る