this post was submitted on 05 Aug 2023
8 points (100.0% liked)

Programming Languages

1167 readers
11 users here now

Hello!

This is the current Lemmy equivalent of https://www.reddit.com/r/ProgrammingLanguages/.

The content and rules are the same here as they are over there. Taken directly from the /r/ProgrammingLanguages overview:

This community is dedicated to the theory, design and implementation of programming languages.

Be nice to each other. Flame wars and rants are not welcomed. Please also put some effort into your post.

This isn't the right place to ask questions such as "What language should I use for X", "what language should I learn", and "what's your favorite language". Such questions should be posted in /c/learn_programming or /c/programming.

This is the right place for posts like the following:

See /r/ProgrammingLanguages for specific examples

Related online communities

founded 1 year ago
MODERATORS
 

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?

you are viewing a single comment's thread
view the rest of the comments
[–] JustTesting@lemmy.hogru.ch 1 points 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.