Using a struct within a struct produces errors

Questions / Help
, , ,
1

I have the following code:

defmodule Servy.Conv do
  defstruct method: "", path: "", resp_body: "", status: nil

  def full_status(conv) do
    "#{conv.status} #{status_reason(conv.status)}"
  end

  defp status_reason(code) do
    %{
      200 => "OK",
      201 => "Created",
      401 => "Unauthorized",
      403 => "Forbidden",
      404 => "Not Found",
      500 => "Internal Server Error"
    }[code]
  end
end

I get a “could not find struct” error when I update the full_status function to def full_status(%Conv = conv) do, even though the struct is defined above. Additionally, Visual Studio Code mentions

Cyclic module usage

When I try to do this. Any ideas?

2

The struct’s module is Servy.Conv not Conv. You have a few choices. You could use the full module name, or you could alias or you could use the compile time variable __MODULE__. For example:

def full_status(%__MODULE__{} = conf) do

I prefer the compile time variable because if you ever refactor the module and change its name, this will reflect the current name.

3 Likes
3

So even though you’re inside the actual struct definition, you still have to alias it, correct? I know the course mentions using alias, but that was when you wanted to use the struct in another file.

4

Yes, but it’s even more fundamental than that. The struct “name” is a module name. Even if you were not creating a struct, but in any module you cannot refer to the current module by the leaf part of its name. For example, if you were writing any function within module Foo.Bar you cannot use Bar by itself. You’d have the same 3 options I mentioned.

4 Likes
5

Just to put what @gregvaughn another way (which is what helped me) is that Elixir doesn’t technically have submodules. The . is a bit of an illusion and is only meaningful for constructs like alias, otherwise it’s just like any other character in a module name. Foo and Foo.Bar have absolutely no relation as far as the VM is concerned.

4 Likes
6

It’s weird because this is perfectly valid:

defmodule Servy.Handler do
  alias Servy.Conv

  @moduledoc "Handles HTTP requests"

  @pages_path Path.expand("pages", File.cwd!())

  @doc "Transforms the request into a response."
  def handle(request) do
    request
    |> route
    |> format_response
  end

  def route(%Conv{method: "GET", path: "/wildthings"} = conv) do
    %{conv | status: 200, resp_body: "Bears, Lions, Tigers"}
  end

  def route(%Conv{method: "GET", path: "/pages/" <> file} = conv) do
    Path.expand("../../pages", __DIR__)
    |> Path.join(file <> ".html")
    |> File.read()
    |> handle_file(conv)
  end

  def route(%Conv{method: "GET", path: "/about"} = conv) do
    Path.expand("../../pages", __DIR__)
    |> Path.join("about.html")
    |> File.read()
    |> handle_file(conv)
  end

  def route(%Conv{path: path} = conv) do
    %{conv | status: 404, resp_body: "No #{path} here"}
  end

  def format_response(%Conv{} = conv) do
    # TODO: Use values in the map to create an HTTP response string:
    """
    HTTP/1.1 #{Conv.full_status(%Conv{} = conv)}
    Content-Type: text/html
    Content-Length: #{byte_size(conv.resp_body)}

    #{conv.resp_body}
    """
  end
end

request = """
GET /wildthings HTTP/1.1
Host: example.com
User-Agent: ExampleBrowser/1.0
Accept: */*

"""

response = Servy.Handler.handle(request)

IO.puts(response)
7

You have alias Servy.Conv at the top of module, unless you’re talking about something else.

1 Like
8

I mean that functions inside the module are fine, but structs inside the module still need to be aliased. Just something that I have to get used to, I guess.

9

That goes back to what Greg was saying that structs are named after the module itself. This is no different than if you want to use a module within itself: you either have to use __MODULE__ or you can type the full name verbatim.

As I said in my previous answer, Foo.Bar and Foo are completely different modules. It sounds like you are still thinking of it as Bar is a module within Foo. This is not the case, they are totally independent. Just think of . as an underscore. The . between the module name and the function, however, is an operator, though. It’s separating module and function name.

Sorry for the all the edits but I perhaps it’s clearer to say that the Foo in Foo and the Foo in Foo.Bar also have absolutely no relation.

4 Likes
10

Cool, thanks everyone. Sorry about the dumb questions. I am still learning Elixir, and slowly but surely I will get there.

1 Like
11

I agree this behavior is confusing; I also think it would be more intuitive to alias the current module into itself. I can’t explain exactly why, it’s just less surprising for some reason.

With that said, obviously there is no changing this now, so it is what it is.

Structs are just maps with an extra __struct__ key set to the module name. Functions are imported into the scope, but structs are not. You can only alias the module name.

Note however that defining a nested module aliases that module within the parent, so you can do this:

defmodule A do
  defmodule B do
    defstruct [:foo, :bar]
  end
  def foo(%B{}), do: true
end

Even though the actual name of B is A.B. Which only makes it more confusing tbh.

5 Likes
12

No prob! It’s a bit confusing at first, especially since it’s set up to look like submodules.

What’s even more confusing is that a nested defmodule will auto-alias and then in that case you can do what you’re talking about :sweat_smile:

defmodule Foo do
  defmodule Bar do
    defstruct [:id]
  end

  %Bar{} # This is ok
end

Also some macros, like Phoenix.Router’s scope can cause confusion around this.

EDIT: D’oh @garrison beat me to it :slight_smile:

3 Likes
13

Also so long as I’m blabbing on here (I used to be quite confused about this myself) it could either help or be more confusing to understand that Foo.Bar is syntactic sugar for :"Elixir.Foo.Bar". This makes it really obvious that the . is more of a random character treated specially only by some macros. Playing around in IEx may help:

iex(1)> :"Elixir.String" == String
true
iex(2)> :"Elixir.String".capitalize("foo")
"Foo"
iex(3)> defmodule Foo, do: (def hi, do: "hi")
{:module, Foo,
 <<70, 79, 82, 49, 0, 0, 5, 64, 66, 69, 65, 77, 65, 116, 85, 56, 0, 0, 0, 164,
   0, 0, 0, 17, 10, 69, 108, 105, 120, 105, 114, 46, 70, 111, 111, 8, 95, 95,
   105, 110, 102, 111, 95, 95, 10, 97, 116, ...>>, {:hi, 0}}
iex(4)> :"Elixir.Foo".hi()
"hi"
2 Likes
14

It’s worth pointing out that the reason for this is to ensure an Elixir module name will never collide with an Erlang module name.

2 Likes
15

It might also help to point out that alias Foo.Bar is shorthand for alias Foo.Bar, as: Bar. Both mean that within that scope you can use Bar to refer to Foo.Bar. But, you can name the alias something else like alias Foo.Bar, as: Baz and then use Baz within that scope

2 Likes