Types that you wish were in Elixir

We can probably get syntactic sugar for string-keyed and atom-keyed maps? Technically these:

%{String.t() => term()} 
%{atom() => term()} 

…should be enough, but I do wonder whether having builtin syntax won’t help further adoption. Something like e.g. string_map() and atom_map().

Maybe some imitation of sum types as well? So instead of this:

@type pixel_value :: :red | :blue | :green

…we can have this:

@type pixel_value :: Enum(red | blue | green)

That would be just some syntactic sugar.

But I don’t think the community will agree on alternative syntaxes for things you already can express. I am mostly thinking out loud here.

Hi @dimitrarvp, thanks for chiming in. Note that the intention of the post is not to make a proposal to the language. Just dream and list types that you find useful in your day-to-day development.

In that case I’ll stand by by my suggestion of having convenient and accepted aliases for string-keyed and atom-keyed maps. While you can easily express them as shown above, IMO it will pay off to have something more intuitively named.

Yes, I was also writing some aliases for the empty types.
There is a divergence between pattern matching and type specs, for example, the type %{} .. is that a synonym for map() or for an empty map?
some for <<>>, so i created

@type empty_bitstring :: <<>>

@type empty_binary :: <<>>

@type empty_map :: %{}

This is my wishlist:

String literals:

@type my_string::"foo"

List literals:

@type my_list::[:foo, :bar]

Min-length tuples

@type my_tuple_at_least_two :: {any, any, ...}

I am surprised that literals are not accepted!

Well, I have put up this little library,
https://github.com/eksperimental/extended_types

The usage is quite simple.

      defmodule Foo do
        use ExtendedTypes, all?: true

        @spec sample :: nonempty_keyword()
        def sample(), do: [a: 1]
      end

      defmodule Bar do
        use ExtendedTypes, only: [string_map: 0, atom_map: 0]

        @spec my_map(atom) :: atom_map()
        @spec my_map(String.t) :: string_map()
        def my_map(key) when is_atom(key), do: %{a: 1}
        def my_map(key) when is_binary(key), do: %{"a" => 1}
      end

If you run mix docs you can see all the supported types under the ExtededTypes.Types module.

Please let me know if you think it could be improved in any way.
Thank you.

Where would a type like this be useful?

Liveview handle_event callback is the first to come to mind

Anything json related too