Static[int] can't be used in dict, list or tuple

[ghuls]

Static[int] can't be used in dict, list or tuple:

int_to_static_int = {i: Static[i] for i in range(1, 21)}

test.codon:1 (32-33): error: expected 'int', 'bool' or 'str'

int_to_static_int = [Static[i] for i in range(1, 21)]

test.codon:1 (32-33): error: expected 'int', 'bool' or 'str'

int_to_static_int = (Static[i] for i in range(1, 21))

test.codon:1 (32-33): error: expected 'int', 'bool' or 'str'

[arshajii]

Thanks @ghuls -- out of curiosity, what's the use case here? Static[int] represents a compile-time constant, so they can't meaningfully be put into collections. Are you trying to create a compile-time constant collection?

[ghuls]

I want to have a compiled codon program (codon build -exe ...) to which a can give an argument which supports only specific values (e.g. 1 to 20) which will be used in the program as a Static[int] when passed to a function.

[dibrinsofor]

@ghuls It looks like you are trying to use Static[T] as a runtime value in a container, which Codon currently does not support. Static is a compile-time specialization type not intended as elements in dicts, lists, or tuples.

You might want to look into static loops with Literal[T] instead: https://docs.exaloop.io/language/meta/#static-loops.

[arshajii]

@ghuls would a pattern like this work?

def foo(n: Literal[int]):
    print(f'foo n={n}')

def call_with_static(n: int):
    import codon.static as static
    for i in static.range(1, 21):
        if n == i:
            return foo(i)
    raise ValueError(f'invalid value for n: {n}')


import sys
call_with_static(int(sys.argv[1]))

[ghuls]

Yes the last pattern works.

I had something like this in the meantime:

import sys

def foo(n: Static[int]):
    print(f'foo n={n}')

n = int(sys.argv[1])

for i in static.range(1, 21):
    if n == i:
        foo(i)

It would be nice if the same could be achieved with match/case statements, where codon can figure out that case 1 ... 20 can be considered literals.

def foo(n: Literal[int]):
    print(f'foo n={n}')

def call_with_static(n: int):
    match n:
        case 1 ... 20:
            return foo(n)
        case _:
            raise ValueError(f'invalid value for n: {n}')


import sys
call_with_static(int(sys.argv[1]))

[ghuls]

Another related question.

Is there an easy way to read a FASTA file with sequences of different length (1-20), convert those to Kmers and save them per Kmer length.

Storing them in a dictionary like below does not work (if I remember correctly) as the type for the values are different for each key:

kmer_lengths_to_kmers = {
    1: Set[Kmer[1]],
    2: Set[Kmer[2]],
    ...
    20: Set[Kmer[20]],
}

[ghuls]

@arshajii Is there a way to store Kmers of different lengths in an object and to return a list/set of them of a specific length from a method?

from bio import *


class SeqletsKmers:
    seqlet_kmer1: Set[Kmer[1]]
    seqlet_kmer2: Set[Kmer[2]]
    seqlet_kmer3: Set[Kmer[3]]
    seqlet_kmer4: Set[Kmer[4]]
    seqlet_kmer5: Set[Kmer[5]]
    seqlet_kmer6: Set[Kmer[6]]
    seqlet_kmer7: Set[Kmer[7]]
    seqlet_kmer8: Set[Kmer[8]]
    seqlet_kmer9: Set[Kmer[9]]
    seqlet_kmer10: Set[Kmer[10]]
    seqlet_kmer11: Set[Kmer[11]]
    seqlet_kmer12: Set[Kmer[12]]
    seqlet_kmer13: Set[Kmer[13]]
    seqlet_kmer14: Set[Kmer[14]]
    seqlet_kmer15: Set[Kmer[15]]
    seqlet_kmer16: Set[Kmer[16]]
    seqlet_kmer17: Set[Kmer[17]]
    seqlet_kmer18: Set[Kmer[18]]
    seqlet_kmer19: Set[Kmer[19]]
    seqlet_kmer20: Set[Kmer[20]]

    def __init__(self):
        self.seqlet_kmer1: Set[Kmer[1]] = set()
        self.seqlet_kmer2: Set[Kmer[2]] = set()
        self.seqlet_kmer3: Set[Kmer[3]] = set()
        self.seqlet_kmer4: Set[Kmer[4]] = set()
        self.seqlet_kmer5: Set[Kmer[5]] = set()
        self.seqlet_kmer6: Set[Kmer[6]] = set()
        self.seqlet_kmer7: Set[Kmer[7]] = set()
        self.seqlet_kmer8: Set[Kmer[8]] = set()
        self.seqlet_kmer9: Set[Kmer[9]] = set()
        self.seqlet_kmer10: Set[Kmer[10]] = set()
        self.seqlet_kmer11: Set[Kmer[11]] = set()
        self.seqlet_kmer12: Set[Kmer[12]] = set()
        self.seqlet_kmer13: Set[Kmer[13]] = set()
        self.seqlet_kmer14: Set[Kmer[14]] = set()
        self.seqlet_kmer15: Set[Kmer[15]] = set()
        self.seqlet_kmer16: Set[Kmer[16]] = set()
        self.seqlet_kmer17: Set[Kmer[17]] = set()
        self.seqlet_kmer18: Set[Kmer[18]] = set()
        self.seqlet_kmer19: Set[Kmer[19]] = set()
        self.seqlet_kmer20: Set[Kmer[20]] = set()

    #def __getitem__(self, kmer_size: Literal[int]) -> Set[Kmer[kmer_size]]:
    def __getitem__(self, kmer_size: Literal[int]) -> Union[Set[Kmer[1]]|Set[Kmer[2]]|Set[Kmer[3]]|Set[Kmer[4]]|Set[Kmer[5]]|Set[Kmer[6]]|Set[Kmer[7]]|Set[Kmer[8]]|Set[Kmer[9]]|Set[Kmer[10]]|Set[Kmer[11]]|Set[Kmer[12]]|Set[Kmer[13]]|Set[Kmer[14]]|Set[Kmer[15]]|Set[Kmer[16]]|Set[Kmer[17]]|Set[Kmer[18]]|Set[Kmer[19]]|Set[Kmer[20]]]:
        match kmer_size:
            case 1:
                return self.seqlet_kmer1
            case 2:
                return self.seqlet_kmer2
            case 3:
                return self.seqlet_kmer3
            case 4:
                return self.seqlet_kmer4
            case 5:
                return self.seqlet_kmer5
            case 6:
                return self.seqlet_kmer6
            case 7:
                return self.seqlet_kmer7
            case 8:
                return self.seqlet_kmer8
            case 9:
                return self.seqlet_kmer9
            case 10:
                return self.seqlet_kmer10
            case 11:
                return self.seqlet_kmer11
            case 12:
                return self.seqlet_kmer12
            case 13:
                return self.seqlet_kmer13
            case 14:
                return self.seqlet_kmer14
            case 15:
                return self.seqlet_kmer15
            case 16:
                return self.seqlet_kmer16
            case 17:
                return self.seqlet_kmer17
            case 18:
                return self.seqlet_kmer18
            case 19:
                return self.seqlet_kmer19
            case 20:
                return self.seqlet_kmer20
            case _:
                raise ValueError("Unsupported kmer length {i}.")

    def add_seqlet(self, seqlet: seq):
        kmer_size = len(seqlet)
        match kmer_size:
            case 1:
                self.seqlet_kmer1.add(Kmer[1](seqlet))
            case 2:
                self.seqlet_kmer2.add(Kmer[2](seqlet))
            case 3:
                self.seqlet_kmer3.add(Kmer[3](seqlet))
            case 4:
                self.seqlet_kmer4.add(Kmer[4](seqlet))
            case 5:
                self.seqlet_kmer5.add(Kmer[5](seqlet))
            case 6:
                self.seqlet_kmer6.add(Kmer[6](seqlet))
            case 7:
                self.seqlet_kmer7.add(Kmer[7](seqlet))
            case 8:
                self.seqlet_kmer8.add(Kmer[8](seqlet))
            case 9:
                self.seqlet_kmer9.add(Kmer[9](seqlet))
            case 10:
                self.seqlet_kmer10.add(Kmer[10](seqlet))
            case 11:
                self.seqlet_kmer11.add(Kmer[11](seqlet))
            case 12:
                self.seqlet_kmer12.add(Kmer[12](seqlet))
            case 13:
                self.seqlet_kmer13.add(Kmer[13](seqlet))
            case 14:
                self.seqlet_kmer14.add(Kmer[14](seqlet))
            case 15:
                self.seqlet_kmer15.add(Kmer[15](seqlet))
            case 16:
                self.seqlet_kmer16.add(Kmer[16](seqlet))
            case 17:
                self.seqlet_kmer17.add(Kmer[17](seqlet))
            case 18:
                self.seqlet_kmer18.add(Kmer[18](seqlet))
            case 19:
                self.seqlet_kmer19.add(Kmer[19](seqlet))
            case 20:
                self.seqlet_kmer20.add(Kmer[20](seqlet))
            case _:
                raise ValueError("Unsupported kmer length {i}.")


sk = SeqletsKmers()

# Add some sequences of different length:
sk.add_seqlet(s"ACGT")
sk.add_seqlet(s"ACGTTAA")
sk.add_seqlet(s"CGAT")
sk.add_seqlet(s"GCATTAC")

# Get Kmers with length 4:
print(sk[4])

# Get Kmers with length 4:
#   ==> does not work with:
#       def __getitem__(self, kmer_size: Literal[int]) -> Set[Kmer[kmer_size]]:
static_literal_int_test5.codon:52 (17-41): error: 'Set[Kmer[4]]' does not match expected type 'Set[Kmer[1]]'
╰─ static_literal_int_test5.codon:150 (7-12): error: during the realization of __getitem__(self: SeqletsKmers, kmer_size: 4)

[inumanag]

@ghuls Not yet sadly. Current k-mer design is indeed a bit strict and we plan to change it one day (the Literals/Statics are inflexible now because they are just mostly used to instantiate some special functions, akin to C++'s template ints).