In the very same moment I see types like this, this means one of 2 things to me:
load_ressource_from_file and load_ressource_from_url
That wasn’t my example, it was someone else’s (@lud) that posted with the intent to be verbose, and I illustrated that it could be less verbose with modern constructs like type aliases. I personally wouldn’t ever write code this confusing in any language, please don’t attribute the example to me.
This is not what I suggested or implied. In Swift you can write:
typealias Transportable = Codable & Hashable
struct PushReply<Payload: Transportable>: Transportable {
var joinRef: String?
var ref: String?
var topic: String
var event: String?
var container: Container<Payload>
struct Container<ContainerPayload: Transportable>: Transportable {
var response: ContainerPayload
var status: String
}
}
The typealias allows you to combine types and then cleanly represent that combination in function signatures and structures, rather than repeating the individual types themselves everywhere. While this is not exactly the same as your example returning one of the following statuses $ type payment_status = :trial | {:success, metadata} | {:overdue, metadata} (essentially and vs or) but the benefit of avoiding verbosity still remains.
By the way, your Kotlin code makes alot of sense to me:
fun handle(value: String): String = value.uppercase()
fun handle(value: Int): Boolean = value % 2 == 0
fun handle(value: List<Any>): Int = value.size
And if I were to write it intuitively in elixir with inline types, it would be something like:
def handle(value :: Int) :: String, do: String.upcase(value)
def handle(value :: String) :: Boolean, do: rem(value, 2) == 0
def handle(value :: List) :: Int, do: length(value)
What would it look like with the proposed $ notation?
Again worth repeating this is not my code, and you’re critiquing as if someone would actually try to write this? I’d fire someone immediately if I saw this commit, and if an LLM spit this out I would call up Sam Altman myself to complain.
Let’s move on from this code since it seems to have transformed into a red herring of invalidation, which is disingenuous to the post itself and the concerns that have been raised.
If the code you modified is not your actual suggestion on how you would type those functions, then you still have not answered how you would actually type those examples. 
Otherwise, the only signature you posted so far is the one-line inc function, which we should all agree is not representative of the majority of the written code out there.
So in order to be concrete:
How would you type the log_payment_status function? In your reply, you repeated the type signature and made the function partially match the content of the aliases, which as I explained in my previous reply, it is not natural to other languages, so it is confusing and repetitive (even if we completely disregard the proposed hostname function).
How would you type the original hostname function then? Remember that type signatures cannot replace pattern matching and guards, as they are more expressive than type signatures. We can pattern match on integers, empty lists, sequences, binaries, and none of those can be expressed in any of the type systems of the languages above.
We can look at Swift and Kotlin code and translate that to Elixir but that’s not the task at hand. The job is to type existing Elixir code and support the language idioms. So how would you type the examples that have already been shown in this thread?
For completeness, here is how the hostname function would be typed with our proposed types:
$ URI.t() or binary() or nil -> binary() or nil
def hostname(%URI{host: host}), do: host
def hostname(url) when is_binary(url), do: hostname(URI.parse(url))
def hostname(nil), do: nil
Even better, here is the relatively small URI module from Elixir. Can you go through every function and type them according to your proposal? elixir/lib/elixir/lib/uri.ex at main · elixir-lang/elixir · GitHub - the new type system would be quite similar to the existing specs, so that’s a good reference, but I can write a complete version as a follow up to yours. This will allow us to move the discussion into actual working code, rather than one-liners or fictional examples. Otherwise, we will all be guessing what you actually meant, which is not fair to you (nor anyone else).
That wasn’t my example, it was someone else’s (@lud) that posted with the intent to be verbose, and I illustrated that it could be less verbose with modern constructs like type aliases. I personally wouldn’t ever write code this confusing in any language, please don’t attribute the example to me.
I also gave an example with typealiases, before anybody else, to go partially in your direction.
Again worth repeating this is not my code, and you’re critiquing as if someone would actually try to write this? I’d fire someone immediately if I saw this commit, and if an LLM spit this out I would call up Sam Altman myself to complain.
This is your code though, a variation on mine. And while I agree that using type aliases makes it look more correct, it does not change the fact that a clause declares %URI{} :: URI | String? which is strange.
@lud I agree that you brought up typealiases (even before I mentioned) and I’m aligned with your thinking and examples – I should have called out this alignment more, instead of focusing on just the counter-intuitiveness of how this example’s signature was written.
I think Jose derailed a bit by stating I found this particularly confusing in the other example you posted and Not only it is repetitive and confusing, it also means we are incapable of expressing function overloads when it wasn’t my original code, and the only modification was going from String.t() | nil to String? to illustrate optional types will improve clarity and conciseness.
Do we all agree that this %URI{host: host} :: URI.t()) :: String.t() | nil is more concise+readable with optional type sugar (?) and typealiases, as you first mentioned? I would think the answer is universally “yes”.
The real debate is that even with modern syntax (typealiases, optional type String?, and potentially others), do inline types still not fit with elixir? Is $ just that much better for this language? Let’s continue on that path..
Great suggestion Jose, here is uri.ex with just typealiases and optional types. There are a few other modern constructs that could potentially improve even more, but I think this is aligned to what’s possible in the current scope of work.
defmodule URI do
@moduledoc """
Utilities for working with URIs.
"""
# Type aliases for better readability
typealias Scheme :: String?
typealias Host :: String?
typealias Port :: non_neg_integer?
typealias Path :: String?
typealias Query :: String?
typealias Fragment :: String?
typealias Userinfo :: String?
typealias URIString :: String
typealias EncodingType :: :www_form | :rfc3986
typealias QueryMap :: %{String => String}
typealias QueryEnum :: Enumerable.t()
typealias QueryPair :: {String, String}
typealias Predicate :: (byte -> boolean)
typealias Authority :: String?
@derive {Inspect, optional: [:authority]}
defstruct [:scheme, :authority, :userinfo, :host, :port, :path, :query, :fragment]
# Core URI functions
def default_port(scheme :: String) :: Port
def default_port(scheme :: String, port :: non_neg_integer) :: :ok
# Query encoding/decoding
def encode_query(enumerable :: QueryEnum, encoding :: EncodingType \\ :www_form) :: String
def decode_query(query :: String, map :: QueryMap \\ %{}, encoding :: EncodingType \\ :www_form) :: QueryMap
def query_decoder(query :: String, encoding :: EncodingType \\ :www_form) :: Enumerable.t()
# Character classification
def char_reserved?(character :: byte) :: boolean
def char_unreserved?(character :: byte) :: boolean
def char_unescaped?(character :: byte) :: boolean
# Encoding/decoding
def encode(string :: String, predicate :: Predicate \\ &char_unescaped?/1) :: String
def encode_www_form(string :: String) :: String
def decode(uri :: String) :: String
def decode_www_form(string :: String) :: String
# URI creation and parsing
def new(uri :: t | URIString) :: {:ok, t} | {:error, String}
def new!(uri :: t | URIString) :: t
def parse(uri :: t | String) :: t
# URI manipulation
def to_string(uri :: t) :: String
def merge(base :: t | String, rel :: t | String) :: t
def append_query(uri :: t, query :: String) :: t
def append_path(uri :: t, path :: String) :: t
# Private helper functions
defp encode_kv_pair({key, _} :: QueryPair, _encoding :: EncodingType) when is_list(key)
defp encode_kv_pair({_, value} :: QueryPair, _encoding :: EncodingType) when is_list(value)
defp encode_kv_pair({key, value} :: QueryPair, :rfc3986 :: EncodingType) :: String
defp encode_kv_pair({key, value} :: QueryPair, :www_form :: EncodingType) :: String
defp decode_query_into_map(query :: String, map :: QueryMap, encoding :: EncodingType) :: QueryMap
defp decode_query_into_dict(query :: String, dict :: any, encoding :: EncodingType) :: any
defp decode_next_query_pair("" :: String, _encoding :: EncodingType) :: nil
defp decode_next_query_pair(query :: String, encoding :: EncodingType) :: {QueryPair, String}?
defp decode_with_encoding(string :: String, :www_form :: EncodingType) :: String
defp decode_with_encoding(string :: String, :rfc3986 :: EncodingType) :: String
defp percent(char :: byte, predicate :: Predicate) :: String
defp hex(n :: byte) :: byte when n <= 9
defp hex(n :: byte) :: byte
defp unpercent(binary :: String, acc :: String, spaces :: boolean) :: String
defp hex_to_dec(n :: byte) :: byte?
defp uri_from_map(%{path: ""} = map :: map) :: t
defp uri_from_map(map :: map) :: t
defp parse_string(string :: String) :: t
defp nilify_query("?" <> query :: String) :: String
defp nilify_query(_other :: any) :: nil
defp split_authority("" :: String) :: {nil, nil, nil, nil}
defp split_authority("//" :: String) :: {Authority, nil, String, nil}
defp split_authority("//" <> authority :: String) :: {Authority, Userinfo?, Host?, Port?}
defp nilify("" :: String) :: nil
defp nilify(other :: any) :: any
defp merge_paths(nil :: nil, rel_path :: Path) :: Path
defp merge_paths(_ :: Path, "/" <> _ = rel_path :: Path) :: Path
defp merge_paths(base_path :: Path, rel_path :: Path) :: Path
defp remove_dot_segments_from_path(nil :: nil) :: nil
defp remove_dot_segments_from_path(path :: String) :: String
defp path_to_segments(path :: String) :: [String | atom]
defp remove_dot_segments(segments :: [String | atom], acc :: [String | atom]) :: [String | atom]
defp join_reversed_segments([:/] :: [atom]) :: String
defp join_reversed_segments(segments :: [String | atom]) :: String
end
defimpl String.Chars, for: URI do
def to_string(uri :: URI.t()) :: String
defp extract_authority(%{host: nil, authority: authority} :: URI.t()) :: String?
defp extract_authority(%{host: host, userinfo: userinfo, port: port} :: URI.t()) :: iodata
end
I don’t see how the ? could make sense. Is URI | String? supposed to mean URI | String | nil or URI | (String | nil)? Because it reads like the latter but works like the former, no?
Thank you @smueller for providing this example. However, I must point out that you are not fully showcasing what you proposed, given several functions had their clauses elided, such as new, new!, parse, remove_dot_segments, merge, hex_to_dec, and unpercent.
I’d love if you could actually annotate the existing clauses in the URI module, at least for these functions, showing all clauses alongside patterns and guards (you can elide the parts inside the do-block with … for conciseness). It is important to preserve the clauses for inline annotations because one of the arguments against them is that they get repetitive. Otherwise, you are effectively keeping them separate from the existing code, which I must agree looks really good. 
Besides the above, here is a question you should answer: do you agree with the previous comment by Wojtek and myself, which said that the following clause is confusing (and I would say semantically invalid), because it says it accepts URI, String and nil, but in practice that particular clause only deals with String?
def hostname(url :: URI | String?) when is_binary(url) :: String?, do: hostname(URI.parse(url))
^^^^^ ^ ^^^^^^^^^^^^^^^^^^^
Or do you believe such definitions should be accepted? I am asking semantically, disregard the syntax for now.
PS: type aliases are part of the type system. I am not convinced about String? though. I think it is worth being more explicit around nil usage, but this is something I can change my mind once we start using the type system in practice and it feels too verbose. Feel free to use it in your example, it is not relevant to the discussion at hand.