Elixir Gotchas (pragtob.wordpress.com)

I'm not sure this is true? Or I misinterpret.

    Erlang/OTP 27 [erts-15.0] [source] [64-bit] [smp:4:4] [ds:4:4:10] [async-threads:1] [jit:ns]
    Interactive Elixir (1.17.1) - press Ctrl+C to exit (type h() ENTER for help)
    iex(1)> defmodule X, do: defstruct [:a]
    {:module, X,
     <<70, 79, 82, 49, 0, 0, 7, 128, 66, 69, 65, 77, 65, 116, 85, 56, 0, 0, 0, 244,
       0, 0, 0, 22, 8, 69, 108, 105, 120, 105, 114, 46, 88, 8, 95, 95, 105, 110,
       102, 111, 95, 95, 10, 97, 116, 116, 114, ...>>, %X{a: nil}}
    iex(2)> x = %X{a: 1}
    %X{a: 1}
    iex(3)> x[:a]
    ** (UndefinedFunctionError) function X.fetch/2 is undefined (X does not implement the Access behaviour

    You can use the "struct.field" syntax to access struct fields. You can also use Access.key!/1 to access struct fields dynamically inside get_in/put_in/update_in)
        X.fetch(%X{a: 1}, :a)
        (elixir 1.17.1) lib/access.ex:322: Access.get/3
        iex:7: (file)
    iex(4)> get_in(x, [:a])
    ** (UndefinedFunctionError) function X.fetch/2 is undefined (X does not implement the Access behaviour

    You can use the "struct.field" syntax to access struct fields. You can also use Access.key!/1 to access struct fields dynamically inside get_in/put_in/update_in)
        X.fetch(%X{a: 1}, :a)
        (elixir 1.17.1) lib/access.ex:322: Access.get/3
        iex:7: (file)
    iex(5)> get_in(x, [Access.key!(:a)])
    1

    get_in(x.a)

    get_in(x.a.b.c)

+1 I'd say it's a great read even if you don't plan to do much Erlang or Elixir programming.

Then, when you have code in production, https://www.erlang-in-anger.com/ (from the same author)

Agreed, even with f# a first class citizen in the .net world, written, maintained and distributed by Microsoft, I still have needed to gain a working knowledge of c# to properly interact with the .net libs and third party libs (which I absolutely need to do as the f# ecosystem is tiny compared to c#). So at the end of the day I needed to learn two languages to atain my goal of learning one enough to be useful.

Disclaimer - I am still learning both - I am no expert on either - and I am still strugling!

(Calling erlang from elixir much eaiser!)

Elixir is peculiar in this regard because Elixir adherents outweigh erlang adherents maybe 10:1.

I really wish that someone would magically transpile all of ERTS so the documentation syntax was uniform.

Elixir is almost more of a guest syntax than it is a diff language.

Yeah, just (learn how to) use lists and you'll be fine.

Of course if your goal is to re-implement sorting algorithms that were designed for mutable memory, you will be disappointed.

This isn't a deal-breaker. If you want a platform language, use that. But for web, you'd be hard-pressed to find something better suited than Elixir.

I've only ran into a single instance where I needed array-like access and since it was a read only type of thing tuples worked perfectly.

> random O(n) access

O(1) for reading I believe. The slightly awkward array module is built on top of tuples, a 10-tree of tuples? or something like it.

But good point, once in a while I see list_to_tuple to provide faster indexed reads on lists.

Are you sure you mean O(n) instead of O(1), which I would expect for an array?

Tuples can be up to 16,777,215 elements, so quite substantial applications.

https://www.erlang.org/doc/system/system_limits

There is also some hope that future versions of the Erlang compiler will allow mutable O(1) update of tuple elements through setelement (code inside a process is - almost - guaranteed not to have shared references).

  Safe destructive update of tuples has been implemented
  in the compiler and runtime system. This allows the VM to
  update tuples in-place when it is safe to do so, thus 
  improving performance by doing less copying but also by 
  producing less garbage.

https://github.com/erlang/otp/releases?q=27&expanded=true

It should be possible to add Elixir syntactic sugar to make this more concise and natural.

They are trees, so not O(1) access or update, more like O(logn), with some memory fragmentation for every update, insertion or deletion.

Tuples and binaries give O(1) read access, so depending on your use case, they may be better.

Also look at zippers, finger trees and ropes for more dynamic use, especially local operations (cursors).

Not requiring a package manager is the point. Python, node, Zig etc supply binaries or a binary installer for each major OS, so why not Elixir? I can't see how it'd be a bad thing for anyone.