I want compile errors from router.ex, but everything compiles fine. (?)

Well first there is no static typing in elixir. Second, module names are just atom, no different from any other atom:

iex(4)> Blah == :"Elixir.Blah"
true

So the only way to check it would be to actually call something on it (module_info/0 is a common thing to test). What the get is basically doing is just taking the atom you pass in for the module and the atom you pass in for the function (function names are just atoms too) and basically calling it like apply(moduleAtom, functionAtom, [conn, params]).

Thanks!

I’m seeing the difference outside of the get(), however. E.g., after the defmodule’s end:

NonexistentThing  # No error
nonexistentThing  # error

Are you saying, that NonexistentThing is simply not evaluated? Optimized out before it’s linked?

(Indeed, I see that I get this behavior in a simple mix new project.)

Simply calling NonexistentThing isn’t doing anything. It is just an atom. There is nothing to evaluate. It does not know that you are trying to reference a module. It is just like any other literal. You would not get an error if you replaced it with 4. If instead you tried using NonexistentThing.foo, you should get an error stating that it does not exist.

On the other hand, nonexistentThing is trying to reference a variable that does not exist.

So it could be seen as a language syntax issue. I think it’d be hugely beneficial to get warnings for mis-spelled symbols. I hadn’t realized that an uppercase “bare word” is accepted as a valid expression.

I imagine that this alternate API would provide the kind of compiler checks I’m thinking about:

get("/hello", &HelloController.index/2)

…using capture to pass in an actual function instead of stringly typed values. TBH, I like it - it’s more obvious what get() is doing.

The problem with this syntax is that it would introduce a compile-time dependency on the HelloController module. You don’t want all of your controllers recompiled when you change the router.

The MFA pattern (module,function,arguments) is quite pervasive in BEAM languages. For example compare:
Kernel.spawn/3
Kernel.spawn/1

and as already mentioned
Kernel.apply/3

So while

get("/hello", HelloController, :index)

may look strange coming from other languages, it’s not unusual in OTP to assemble function invocations (or process initializations) as MFA triplets.

Not to be confused with the mfa() type which is actually {module(), atom(), arity()}.

Also, will this not create a lot of functions in the router module?

As far as I remember anonymous functions in the BEAM are just compiled into regular functions with a mangled name in the owning module?

Acutally, it’s all too familiar, coming from Ruby and Rails. I was hoping to get a little more help from the compiler when possible.

Hear hear! If only Elixir had static typing. ^.^;