Hello! Excited to hear about the type system. My main concern would be the adoption and gradual migration to this new type system. A big downside would be that you either migrate fully to types or can’t use them.

Fragmentation and Rust-style drama (the “unsafe” Rust drama, not the political Rust drama… oh, Rust). IE, “How dare you write your library without types!” incidents. I worry it will bring in an influx of people to the community with a different mindset who will make a lot of noise and apply massive pressure to make major changes to the language. I’m not overly concerned about the second as I trust the core team there, but thought I’d voice it (sorry for the extra sentence).

I like the dynamic type,I worry the type system will lost the dynamic type style. Like typescript for JavaScript.

I’m concerned about the syntax for defining types. It should be friendly to new/existing elixir devs while not being too verbose or too vague.

1. How well type system would be integrated in future?
   Would we be able to write a macros with a new dollar ($) syntax just like we are doing now for @spec?
   Would we be able to read information about it from beam files?
   For reference: Dynamically generate typespecs from module attribute list

2. Would we be able to write multiple $ spec like we did for @spec?
   This is supported by ex_doc and not supported by dialyzer?
   For reference: What is the idiomatic way to use @spec?

3. What would happen with @spec and what with ex_doc?
   Would ex_doc prefer $ over @spec or maybe it would just present both of them?
   Would @spec be deprecated in long term or it would be only recommended to use one over another?

1. Verbosity in pattern matching is scary. (People are already asking me to break my non typed / non verbose pipelines!)

2. Hope we don’t have to include typedefs for libraries, like it happens with TypeScript projects.

3. If type system comes, it should be integral to the language, otherwise if it’s optional like @spec or proptypes in React, then my code base will be a mess. (I will become lazy about adding types, just like I leave out tests!)

The biggest annoyance with strong typed languages from my past experiences has always been around inheritance vs composition and the way interfaces abstract the types for encapsulation and polymorphism.

Often times it has more to do with the choice of things people lump into the interfaces calling them abstractions because they don’t have a better place to put said thing.

None of this is a concern of accessibility of said feature but rather use and abuse of the feature.
I think it would be wise to educate as much as possible around good uses cases and anti patterns.

Thank you to all the devs who keep pushing this awesome language.
I’m sure what ever you choose its going to be great,
just let necessity drive innovation and the path will show itself.

I don’t have any concerns.

In support of my comment, I am relatively new to programming and Elixir is the first language I worked with.

Edit: for clarification i.e. I do not fully understand the ramifications.

I worry that:

• The type system won’t be strong enough, i.e. that it will be only a smaller improvement over dialyzer. Ideally, it would do justice to HM Type system (Hindley–Milner type system - Wikipedia) as a minimum.
• The error output of the analyzer will be hard to read for newcomers. A good example is Rust compiler which gives precise and readable errors. A bad example is dialyzer errors as they are.
• There won’t be a standard for how to and where to place type definitions in projects, thus causing types to be scattered all over the projects in random ways.