为什么这个长生不老药功能未定义

Question

I have rebooted my learning of the Elixir language. I am trying to try a variation of the Fizzbuzz problem with the following code.

defmodule FizzBuzz.Fb4a do

  def upto(n) when n > 0 do
    fizzbuzz(n)
  end

  defp toTuple(n), do: {n, ""}

  defp toString({v,a}) do
    if String.length(a) == 0 do v else a end
  end

  defp genFB(d, s) do
    fn ({v, a}) ->
      cond do
        rem(v, d) == 0 -> {v, a+s}
        true           -> {v, a}
      end
    end
  end

  # do3 = genFB(3, "Fizz")
  # do5 = genFB(5, "Buzz")
  # do7 = genFB(7, "Bang")

  defp fizzbuzz(n) do
    1..n
    |> Enum.map(&toTuple/1)
    # |> Enum.map(&do3/1)
    # |> Enum.map(&do5/1)
    # |> Enum.map(&do7/1)
    |> Enum.map(&toString/1)
  end

end

When I uncomment the do3 = genFB(3, "Fizz") line, I get the following error:

** (CompileError) lib/fib4a.ex:22: undefined function genFB/2

I do not understand how genFB/2 can be undefined or not seen by the compiler. I have obviously missed something very fundamental in the definition of functions somewhere. What have I missed?

Answer 1

I do not understand how genFB/2 can be undefined or not seen by the compiler. I have obviously missed something very fundamental in the definition of functions somewhere. What have I missed?

This example doesn't work either:

defmodule My do
  def greet do
    IO.puts "hello"
  end

  greet()
end

In iex:

~/elixir_programs$ iex my.exs
Erlang/OTP 20 [erts-9.3] [source] [64-bit] [smp:4:4] [ds:4:4:10] [async-threads:10] [hipe] [kernel-poll:false]

** (CompileError) my.exs:6: undefined function greet/0

Same error here:

defmodule My do
  def greet do
    IO.puts "hello"
  end

  My.greet()
end

The reason is that defining a function doesn't introduce a name into the module scope, and you are calling the function at the module scope (for some unexplained reason).

Named Functions And Modules

...named functions have a couple of peculiarities.

First, defining a named function does not introduce a new binding into the current scope:

 defmodule M do def foo, do: "hi" foo() # will cause CompileError: undefined function foo/0 end 

Second, named functions cannot directly access [the] surrounding scope.

Scoping Rules in Elixir

That fact that def's don't create a name in the module scope should make you wonder how they can be called inside another function.

The answer to this lies in the following rule followed by Elixir when trying to resolve an identifier to its value:

Any unbound identifier is treated as a local function call.

Huh? Translation: you can't call defs in the module scope--that's just the way it is!

I have rebooted my learning of the Elixir language.

You can execute statements in an .exs file like this:

defmodule My do
  def greet do
    IO.puts "hello"
  end

end

My.greet()  #<====  This will execute

---

~/elixir_programs$ iex my.exs
Erlang/OTP 20 [erts-9.3] [source] [64-bit] [smp:4:4] [ds:4:4:10] [async-threads:10] [hipe] [kernel-poll:false]

hello   #<=== Output
Interactive Elixir (1.6.6) - press Ctrl+C to exit (type h() ENTER for help)
iex(1)> 

But if greet/0 is private ( defp ), you can't even do that.

(Why do you name modules FizzBuzz.Fb4a which makes it as irritating as possible to type? What's the matter with the name F4 ?)

Edit: it looks to me like defmodule creates the following scopes:

defmodule My do
  x = 100

  def greet do
    x = 1
  end

  def go do
    x = 3
  end
end

  ||
  VV

+----MyModuleScope-------+ 
|                        |
|    x = 100             |  
|                        |
|    +--greetScope-+     |      +--Invisible Scope--+
|    |   x = 1    -|-----|----->|       greet       |
|    +-------------+     |      |       go          |
|                        |      +-------------------+
|    +--goScope----+     |               ^    
|    |   x = 3    -|-----|---------------+
|    +-------------+     |
|                        |
+------------------------+

You can see that the module scope is not accessible by inner scopes here:

defmodule My do
  x = 10

  def greet do
    IO.puts(x) 

  end

end

My.greet()

In iex:

~/elixir_programs$ iex my.exs
Erlang/OTP 20 [erts-9.3] [source] [64-bit] [smp:4:4] [ds:4:4:10] [async-threads:10] [hipe] [kernel-poll:false]

warning: variable "x" is unused
  my.exs:2

warning: variable "x" does not exist and is being expanded to "x()", please use parentheses to remove the ambiguity or change the variable name
  my.exs:5

** (CompileError) my.exs:5: undefined function x/0
    (stdlib) lists.erl:1338: :lists.foreach/2
    my.exs:1: (file)

The last part is an error saying x is undefined. But, there is a way to access the values in the module scope:

defmodule My do
  x = 10

  def greet do
    x = 1
    IO.puts(unquote(x)) 
    x
  end

end

My.greet()

In iex:

~/elixir_programs$ iex my.exs
Erlang/OTP 20 [erts-9.3] [source] [64-bit] [smp:4:4] [ds:4:4:10] [async-threads:10] [hipe] [kernel-poll:false]

10
Interactive Elixir (1.6.6) - press Ctrl+C to exit (type h() ENTER for help)
iex(1)> 

However, unquote() is a macro so I think that result is just a compiler trick, which doesn't have anything to do with runtime, ie you aren't looking up values in an outer scope, the compiler just inlined the values in your code at compile time.

Answer 2

Compilation stages

I do not understand how genFB/2 can be undefined or not seen by the compiler.

The main thing one should clearly understand about Elixir : it is, unlike many other languages, uses the same syntax for “metaprogramming” and the code itself. Being a compiled language that runs inside a VM, Elixir is unable to execute any arbitrary code . The code must be compiled upfront.

Compilation basically means converting the code into AST and then into BEAM.

The code that is found in the topmost scope (and inside defmodule macro) is being executed on the compilation stage. It is not included into the resulting BEAM. Consider the following example:

defmodule Test do
  IO.puts "🗜️ Compilation stage!"

  def yo, do: IO.puts "⚡ Runtime!"
end

Test.yo

If you'll try to compile this, you'll see "🗜️ Compilation stage!" printed during compilation only. There is no way to refer to this code from the resulting BEAM, because it's simply discarded after execution during compilation.

OTOH, to get the "⚡ Runtime!" string printed, you need to explicitly run Test.yo in runtime.

That said, your doN variables (even if they were referring valid aka available / known to the compiler functions) are assigned as local variables during the compilation stage and immediately discarded because nobody uses them.

Workaround 1

There are things that are available inside runtime functions:

• module attributes ( Docs , Tutorial )
• macros

Module attributes

They are available because the compiler, when it sees a module attribute and/or macro, injects the resulting AST inplace, without touching it. Consider the following example:

defmodule Test do
  @mod_attr &IO.puts/1

  def yo, do: @mod_attr.("⚡ Runtime!")
end

Test.yo

Here we declared the module attribute, referencing function IO.puts/1 and called it from runtime.

The function we reference must be compiled at the moment it gets referenced .

Macros

Consider the following example.

defmodule Test do
  defmacrop puts(what), do: IO.puts(what)

  def yo, do: puts("🗜️ Compilation time!")
end

Wait, what? TheIt was printed during the compilation stage! Yes, it was. Macros inject the AST produced by their do: block, and therefore IO.puts(what) was executed during the compilation stage .

To fix this behaviour one should quote the content of the macro, to inject it as is instead of executing it.

defmodule Test do
  defmacrop puts(what), do: quote(do: IO.puts(unquote(what)))

  def yo, do: puts("⚡ Runtime!")
end

Test.yo

So, you might have fixed your code by introducing a cumbersome macro, injecting the call to real function, but I'd leave this out of scope of this answer. There is way more easy way to accomplish a task.

Workaround 2

defmodule FizzBuzz.Fb4a do
  def upto(n) when n > 0, do: fizzbuzz(n)

  defp toTuple(n), do: {n, ""}

  defp toString({v, ""}), do: v
  defp toString({_v, a}), do: a

  defp genFB({v, a}, d, s) when rem(v, d) == 0, do: {v, a <> s}
  defp genFB({v, a}, _d, _s), do: {v, a}

  defp fizzbuzz(n) do
    1..n
    |> Enum.map(&toTuple/1)
    |> Enum.map(&genFB(&1, 3, "Fizz"))
    |> Enum.map(&genFB(&1, 5, "Bazz"))
    |> Enum.map(&genFB(&1, 7, "Bang"))
    |> Enum.map(&toString/1)
  end
end

I have cleaned up the code a bit to use pattern matching instead of imperative if and cond clauses.

In the first place, you don't need to return a function. Elixir has a nifty feature allowing to capture functions with & . You might even assign the result of curried function to a variable and call it later, but it's not really needed here.

If you still want to assign the intermediate variables, make sure the module the function belongs to is already compiled .

defmodule FizzBuzz.Fb4a do
  defmodule Gen do
    def genFB({v, a}, d, s) when rem(v, d) == 0, do: {v, a <> s}
    def genFB({v, a}, _d, _s), do: {v, a}
  end

  def upto(n) when n > 0, do: fizzbuzz(n)

  defp toTuple(n), do: {n, ""}

  defp toString({v, ""}), do: v
  defp toString({_v, a}), do: a

  defmacrop do3, do: quote(do: &Gen.genFB(&1, 3, "Fizz"))
  defmacrop do5, do: quote(do: &Gen.genFB(&1, 5, "Bazz"))
  defmacrop do7, do: quote(do: &Gen.genFB(&1, 7, "Bang"))

  defp fizzbuzz(n) do
    1..n
    |> Enum.map(&toTuple/1)
    |> Enum.map(do3())
    |> Enum.map(do5())
    |> Enum.map(do7())
    |> Enum.map(&toString/1)
  end
end

---

Hope this helps.