
Can We Have Form Objects in Elixir? - squixy
https://blog.lelonek.me/form-objects-in-elixir-6a57cf7c3d30
======
sjtgraham
I started my application before the embedded_schema API was available and the
Assumption that a RDBMS was backing everything was a major pain-point for me
at the time leading me to create a custom form abstraction using Vex
([https://github.com/CargoSense/vex](https://github.com/CargoSense/vex)). Now
with embedded_schema the pain went away and I ended up refactoring my form
modules away completely in favour of the new API.

I was using Ruby myself for 10 years before using Elixir and the Form object
pattern was one I used very often myself. A general principle of Elixir I have
often seen that if you think something doesn't work, or is the wrong way you
in fact need to unlearn some of the brain damage acquired from Ruby.

A great example of this is Wojtek Mach's github_ecto project
([https://github.com/wojtekmach/github_ecto](https://github.com/wojtekmach/github_ecto)).
His abstracting of the Github API behind a Ecto.Repo was mindblowing to me.
Your app communicates with a HTTP API without knowing it's any different than
your DB.

Elixir is very much a different way of thinking about problems than Ruby.

~~~
bobwaycott
Holy crap. That's amazing. Thanks for sharing. Been digging into Elixir off
and on for months, and hadn't come across this. Mind-blowing, indeed.

------
Cieplak
For what it's worth, I've been learning Erlang and this was my first shot at
json form parsing:

[https://github.com/cieplak/chat/blob/master/src/http/forms.e...](https://github.com/cieplak/chat/blob/master/src/http/forms.erl#L6)

[https://github.com/cieplak/chat/blob/master/src/domain/types...](https://github.com/cieplak/chat/blob/master/src/domain/types/message.erl#L32)

No data validation at the moment, but it would be nice to generate the form
parsing and validation, as well as the getters and setters, from a declarative
spec.

------
J0-nas
Totally of topic but could someone explain Elixirs syntax to me?

In the following code (from the linked site): What is embeds_many? Are :string
and :map type information or Atoms? What happens to :changes, Change,
primary_key? Does the code between do and end just call the field function
twice?

embeds_many :changes, Change, primary_key: false do

    
    
        field :field, :string
    
        field :value, :map
    

end

~~~
lilactown
It's confusing because it's using a library called Ecto, which provides it's
own DSL for describing schemas and queries.

NOTE: I haven never used Ecto, but I have used Elixir for a few hobby
projects.

1\. `embeds_many` is a function name, described here:
[https://hexdocs.pm/ecto/Ecto.Schema.html#embeds_many/3](https://hexdocs.pm/ecto/Ecto.Schema.html#embeds_many/3)

2\. Anything that begins with a colon is an Atom in Elixir, including :string,
:map, :changes, :field, and :value. These atoms are used by Ecto at runtime to
identify certain things. `:changes` is a unique name given to the embedded
schema, `:field` and `:value` are field names on that schema, and :string and
:map are informing Ecto of how to treat certain values.

3\. `Change` is the name of a Module which describes the Schema we are
embedding

4\. `primary_key: false` is a configuration option

5\. Everything after `do...` is describing what the embedded schema would look
like. So it has a `:field` field that is of type string, and a `:value` field
that is of type map.

Hopefully that makes some sense... I'm not totally clear on it either (having
not used Ecto before) but that's what I'm grokking.

~~~
J0-nas
Thanks

------
jaequery
It's good to see more people developing in Elixir. But having said that, I'm
against server-side forms. I feel client side frameworks like vue.js
completely alleviates the need for server-side form objects and does a lot
more. Server-side forms at times can be a real pita to work with.

~~~
conceptme
You still need server side validation so a form object with validators is
still useful.

~~~
out_of_protocol
server side validation (which is indeed requried) != forms. also, Ecto does
really good job with changesets, including hard-to-do-right pieces like
"uniqueness"

~~~
drdaeman
IMHO, reusable server side validation == forms without widgets (and widgets
are nice to have if one feels that JS is unnecessarily complicating what could
be a simple static HTML form).

Or I'm missing something?

