While working with a dynamically typed lang, I came across this:
hash(password, algorithm, algorithmOptions)
Where algorithm is a constant signaling which hashing algorithm to use, and algorithmOptions is a dict whose keys depend on algorithm.
So I thought, can we dictate that if a previous parameter has this value, then this parameter has to have this other value?
E.g.
enum HashAlgo {
Bcrypt,
Argon2,
}
type BcryptOptions = {
Int optionA,
Int optionB,
}
type Argon2Options = {
String optionC,
String optionD,
}
// Here I make this type "depend" on an argument of type HashAlgo
type HashOptions = [HashAlgo] => {
HashAlgo::Bcrypt => BcryptOptions,
HashAlgo::Argon2 => Argon2Options,
}
fun hash(
String password,
HashAlgo algorithm,
// Here I use HashOptions, passing the prev. argument
HashOptions[algorithm] options,
)
This way the compiler can ensure the correct dict is used, based on the value of algorithm
Does something like this exist? I now realize that it would be impossible to type check in compile time based on a runtime value, but if it was allowed only for constants? What do you think?
This would be trivial in python with something like
from typing import overload from enum import Enum @overload def hash(password: str, algorithm: BCryptAlgorithm, options: BCryptOptions): ... @overload def hash(password: str, algorithm: Argon2Algorithm, options: Argon2Options): ... def hash(password: str, algorithm, options): [...implementation...]Of course it’s python, so at runtime it wouldn’t matter, but the static type checker would complain if you called
hashwithBCryptAlgorithmandArgon2Options. You could also have it return different types based on the arguments and then in call sites it’d know which type will be returned based on the type of the arguments. And only the last function has am implementation, the@overloadones are just type signatures.It’s documented here.