理解函数式编程概念的问题

Question

我正在学习函数式编程课程，并且来自 OOP，我试图解决一些我认为非常微不足道的问题，但我只是不理解这里的概念。这是我需要为学校做的练习

给定一个短语，在我的例子中是

“使用 Elixir 进行模式匹配。记住等号是匹配运算符，而不是赋值”

我需要检查每个单词的起始字母是否有匹配的模式，并根据模式应用特定的修改。

我什至不完全确定我当前的代码正在生成什么，当我检查 x 和 y 时，我有点理解循环在做什么，它们有一个短语的每个单词的列表，并且该内部列表包含对每个单词的检查字母，如果不是以该字母开头，则为 nil，如果是，则为修饰词。

我的 OOP 希望这些循环不返回任何“nil”，并且在每次迭代中只返回一个编辑过的单词。在函数式编程中，我不能打破循环并强制返回，所以我需要以另一种方式考虑这一点。

我的问题是我应该如何从函数式编程的角度来解决这个问题？ 一开始我得到一个组成短语的单词列表，然后我希望编辑每个单词，最后再次获得一个包含这些编辑单词的列表。 也许关于如何解决这个问题的类似伪代码的结构可以帮助我理解基本概念。

这是我当前的代码：

#Task two
def taskTwo() do
    IO.puts "Task Two"
    IO.puts "Pattern Matching with Elixir. Remember that equals sign is a match operator, not an assignment"
    IO.puts "Task Two\n...Editing Words ..."
    phrase = String.downcase("Pattern Matching with Elixir. Remember that equals sign is a match operator, not an assignment") |> String.split()
   
    x =  for word <- phrase do
        checkVowels(word)
    end
 
    y =  for word <- phrase do
        checkConsonants(word)
    end

    IO.inspect x
    IO.inspect y

end

#check vowels
def checkVowels(word) do
    vowels = ["a","e","i","o","u"]
    for vowel <- vowels do
        if String.starts_with?(word, vowel) do
           word <> "ay "
        end
    end
end

#check consonants
def checkConsonants(word) do
    consonants = ["b","c","d","f","g","h","j","k","l","m","n","p","q","r","s","t","v","w","x","z","y"]        
    for consonant <- consonants do
        if String.starts_with?(word, consonant) do
           edited = String.replace_prefix(word, consonant, "")
           edited <> consonant <> "ay "
        end
    end
end

我需要申请的修改：首先检查起始字母并应用修改，然后再次检查内部单词是否有任何多字母组合

Words beginning with consonants should have the consonant moved to the end of the word, followed by "ay".
Words beginning with vowels (aeiou) should have "ay" added to the end of the word.
Some groups of letters are treated like consonants, including "ch", "qu", "squ", "th", "thr", and "sch".
Some groups are treated like vowels, including "yt" and "xr".

Answer 1

一种可能的方法（可能不是最有效的，但使用了 Elixir 的一些功能）是使用递归和模式匹配。 所以有一种可能的方法来解决你练习的第一部分。

defmodule Example do
  @vowels ~w[a e i o u y]
  @phrase "Pattern Matching with Elixir. Remember that equals sign is a match operator, not an assignment"

  def task_two() do
    phrase =
      @phrase
      |> String.downcase()
      |> String.split()
      |> Enum.reverse()
      # splitting the first letter of each word
      |> Enum.map(&String.split_at(&1, 1))

    # pass the phrase and an accumulator as arguments
    result = check_words(phrase, [])
    IO.inspect(result)
  end

  # using recursion to traverse the list

  # when the phrase have no more words, it will match the empty list
  def check_words([], phrase) do
    Enum.join(phrase, " ")
  end

  # pattern match on the first letter and using guards to decide if vowel
  def check_words([{first_letter, rest_of_word} | rest_of_list], accumulator)
      when first_letter in @vowels do
    # call the function again, with the rest of the list
    new_word = first_letter <> rest_of_word <> "ay"
    check_words(rest_of_list, [new_word | accumulator])
  end

  # when the pattern does not match for vowels, it should be a consonant

  def check_words([{first_letter, rest_of_word} | rest_of_list], accumulator) do
    new_word = rest_of_word <> first_letter <> "ay"
    check_words(rest_of_list, [new_word | accumulator])
  end
end

您将需要跳过/处理逗号，并且可能需要进行更多调整才能完全发挥作用。但希望它作为一个总体思路有所帮助。

注意事项：

1. 编写测试。它们将真正帮助您了解代码在做什么
2. Elixir 是一种了不起的语言。如果你来自 OOP，一开始可能看起来很奇怪。这本书：Programming Elixir 真的很好，如果你想快速进步，对你有很大帮助。