
Elixir-mail – Build composable mail messages - plehoux
https://github.com/DockYard/elixir-mail
======
bcardarella
I'm the author. This library is still very early in development (two days of
dev time). Its great that its on HN front page but I just want to manage
expectations if you try to use the library. It is still _very_ alpha.

~~~
pmarreck
While I like the composability from a readability standpoint, is this creating
unnecessary VM GC churn due to needing to maintain immutability of the %Mail{}
struct? In other words, would it be better if you could just apply all
attributes at once (with one function call, say "put", that took, say, a Map)?
Or does that basically destroy this convention. lol

~~~
aczerepinski
I doubt this is a performance issue, because it's the same pattern Phoenix
uses to respond to an html request. Phoenix is very fast despite passing the
much larger Plug.Conn struct through a much larger number of functions that
similarly update one thing and return a new copy.

I'd also be curious to know what happens with GC behind the scenes for this
pattern to be so performant - I don't know anything about that part.

~~~
im_down_w_otp
It will be a performance issue at some point. It creates a lot of allocator &
GC churn.

Part of the reason this is mitigated somewhat has to do with how the Beam VM
manages GC. It's per process, which provides a few nice features. One is that
processes that do a lot of "work" tend not to be long-lived, and consequently
they tend not to accrete a lot of heap allocations. The share-nothing
concurrency model enforces an isolation pattern on the developer, which then
allows the GC to make some guaranteed assumptions about what is safe and isn't
safe to reap. The combination of those to factors allows GC sweeps to be both
typically small/short and also done in parallel with other scheduled running
processes, so that GC doesn't block all the execution resources.

Considering the use case here though, I'd really not worry about it. The only
way it'd likely bite you is if you were building a _massive_ scale email
pushing application, and you were weirdly trying to optimize for using as low-
end, or as few, machines as possible to run it, and you hadn't already found
yourself flagged by every mail relay as being a spammer.

------
rgawdzik
For anyone new to Elixir and is interested in it's performance, check out:
[https://github.com/mroth/phoenix-showdown](https://github.com/mroth/phoenix-
showdown)

tldr: It rivals Go in performance.

~~~
TheHippo
For Go it uses the slowest webframework that is available.

~~~
rgawdzik
I don't use golang; what's faster than Gin? It seemed performance centric:
[https://gin-gonic.github.io/gin/](https://gin-gonic.github.io/gin/)

------
cschneid
I like this builder pattern. Seems pretty similar to
[https://hackage.haskell.org/package/optparse-
applicative](https://hackage.haskell.org/package/optparse-applicative) as
well, where you continually apply small functions to a data structure to end
up with a big one.

Since Elixir doesn't have mandatory types, I assume there's no way to verify
at compile time that it's a "valid" email (Has a recipient, and a from addr,
whatever other requirements), and you'd have to check that in tests or at
runtime?

~~~
pmarreck
Unfortunately, email format validation (similar to HTML email) is somewhat of
a black art:

[http://haacked.com/archive/2007/08/21/i-knew-how-to-
validate...](http://haacked.com/archive/2007/08/21/i-knew-how-to-validate-an-
email-address-until-i.aspx/)

[http://girders.org/blog/2013/01/31/dont-rfc-validate-
email-a...](http://girders.org/blog/2013/01/31/dont-rfc-validate-email-
addresses/)

Of course one could always just go with RFC822 and this little regex:

[http://www.ex-parrot.com/pdw/Mail-RFC822-Address.html](http://www.ex-
parrot.com/pdw/Mail-RFC822-Address.html)

~~~
garethadams
The parent wasn't talking about the individual validation of email addresses
(although I guess that may be a part of the answer), but instead about
checking the _presence_ of a recipient, subject, sender etc as part of static
typing.

------
arca_vorago
This is exactly one of the things I have been hoping would get started in
Elixir. I would really like more helpful documentation though.

I'm imagining an entire ecosystem will begin to show up inside Elixir (and
phoenix) as people realize how powerful it can be.

~~~
MCRed
The code uses elixirs built in doc system so you should be able to build docs
after cloning the repo.

At a cursory glance it seems pretty reasonably well documented.

~~~
markatkinson
Yea it's ExDoc, think this should be helpful: [http://elixir-lang.org/getting-
started/mix-otp/docs-tests-an...](http://elixir-lang.org/getting-started/mix-
otp/docs-tests-and-with.html)

On mobile and on the run so can't confirm.

------
kai_hn
Related: A simple SMTP mailer in elixir:
[https://github.com/antp/mailer](https://github.com/antp/mailer)

~~~
awetzel
Also related:
[https://github.com/awetzel/mailibex](https://github.com/awetzel/mailibex)

------
aczerepinski
I don't (currently) have a need for this so I'm not going to play with it
right now, but I like that it looks idiomatically like Plug. Pass a struct
through a pipeline until it's ready to go.

