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?

  • JustTestingA
    1·
    1 year ago

    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 hash with BCryptAlgorithm and Argon2Options. 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 @overload ones are just type signatures.

    It’s documented here.