Using a struct within a struct produces errors

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.

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.

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.

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.

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)

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

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.

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.

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

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.