I was just talking the syntax of def and defp vs something like defpublic and def or whatever, I wasn’t suggesting eliminating private functions. But that is good info I wasn’t aware of! I do remember hearing private functions are faster in some OO languages but I didn’t remember the explanation, so thanks!
sodapopcan
0
lud
I wish we could define “compiler modules” that would be automatically injected into any other modules in the same otp application on compilation to define macros.
We could then override the def macro and implement an export macro 
0
derek-zhou
Erlang’s syntax is fine, in some area even nicer than Elixir. Erlang’s core library and the documentation of them could learn some lessons from Elixir’s counterpart.
2
cmkarlsson
Then you add:
-compile(export_all)
to the module while prototyping and remove it for production. Or even have that as a compile directive for the development environment.
I find the export list preferable to function annotation as you can see a list of all exported functions on top of the module. It is much easier to see rather than scan the entire file to look for public functions.
I’ve seen erlang code where the export list has a comment with a short description
of function signature and description. This is nice when reading but probably but risky to get them out of sync with the real functions and function specs.
-export([
add_something/2, % (#object{}, Incrementor) -> #object{} Add to object
foo/3, % (X, Y, X) -> integer. do foo
bar/2, % (...) -> bar
]).
Perhaps tooling could automate the export list functions.
3
Exadra37
I prefer to have modules with a single responsibility, like handling one action per resource. So, you have a CRUD resource, then you have a module for each of the create, read, update and delete actions. This leads to modules with one single public function, and all the remain functions are private.
I am using this approach for all my projects, and it makes them much easier to understand and read, then all that fat files, that give you the issue you mention of scanning an entire file for public functions.
0
lud
Exadra37
I am not talking about controllers per se, but I see that everyone associates CRUD with controllers because of the MVC style that is a doctrine I don’t like to use.
I used the CRUD as an example to make it easier to understand, but I was not referring to controllers at all.
Example:
See how many actions I have for the todos resource, and they are not inside of the tasks_web folder, instead they are in the core, that can be reused with any web, api or cli implementation of it. They are also inside an api folder, because anything inside this folder is only accessible through the todo_api.ex file, therefore I can easily change my core without affecting the clients consuming it.
1
sodapopcan
Along the lines of documenting exports, I really love how defdelegate requires the args. That way, if you’re doing DDD, your aggregate root will contain a whole bunch of delegates that document, in code, how the entire context works (this is in a scenario where you’d have nested contexts). And it’s hard for them to get out of sync (save for a variable name) as changing the number of arguments or pattern matching will crash.
2
cmo
That is a lot of context switching when you have over a dozen files and folders versus one to a few. How do you justify a file, let alone an entire folder for an add or delete function?
1
