My apologies for posting this very late.
What I did this week
1. Merged the hard-coded restrictions
After making some fixes on the implementation, I had the hard-coded restriction that I explained in the previous post merged.
2. Designed user-defined restrictions
Ultimately, the restrictions on type parameters that we want for LPython is one that users can freely defined according to need. While the hard-coded restrictions can support generics to a certain degree, it cannot handle the various functions that users may define.
Take the mean example from the previous week. With user-defined restrictions, it turns into:
T = TypeVar('T') @restriction def zero(x: T) -> T: pass @restriction def plus(x: T, y: T) -> T: pass @restriction def div(x: T, k: i32) -> f64: pass def mean(x: list[T]) -> f64: k: i32 = len(x) if k == 0: return 0.0 res: T res = zero(x) i: i32 for i in range(k): res = plus(res, x[i]) return div(res, k)
With the hard-coded restrictions, the mean function is limited to handling numbers. However, with user-defined restrictions, it would be possible to pass arguments of any types as long as they have the restriction functions plus, zero, and div provided.
What is coming up next week
I have to conduct a meeting with my mentor and evaluate the current design for user-defined restrictions. Then iterate again on the designs based on the meeting.
Did I get stuck anywhere
I did not have any issue this week as I was freely designing the grammar for the restrictions.