Everything about health IT systems is terrible, from protocols to classification systems. A lot of the problems predate regulations. On the other hand, health IT mirrors the real-world systems it meant to service - complex, rigid, and self-serving
subscript longer_of(_ a: inout String, _ b: inout String): String {
if b.count() > a.count() { yield &b } else { yield &a }
}
fun emphasize(_ z: inout String, strength: Int = 1) {
z.append(repeat_element("!", count: strength)))
}
public fun main() {
var (x, y) = ("Hi", "World")
emphasize(&longer_of[&x, &y])
print("${x} ${y}") // "Hi World!"
}
> This program declares two character strings, appends an exclamation mark to the longest, and prints them both after the mutation. No pointers or references are used (& in Val does not mean “address of”—it simply marks a mutation), and no unnecessary allocation occurs. The result of longer_of is a projection of the longer argument, so the mutation of z by emphasize occurs directly on the value of y. The value is neither copied, nor moved, and yet it is not being passed by reference to emphasize. The body of emphasize owns z in exactly the same way as it owns strength, which is passed by value: z is an independent value that can only be touched by emphasize.
> To better understand, notice that longer_of is not a function; it’s a subscript. A subscript does not return a value, it projects one, granting the caller temporary read and/or write access to it.
I'm not sure if it's due to the name not really conveying what it what sounds like they're trying to describe or my lack of familiarity with other parts of the language, but this page doesn't really give me any clue to what a "subscript" actually is. They're very explicit that it's not a function, but from both the syntax and the usage exactly, it seems to look and act pretty much just like a function. Given that it's supposed to help avoid needing references in the language, I assume that the reason they're making this distinction is to convey that it doesn't use call stack semantics like a function call normally does, so...is it just an inlined function, or a hygenic macro defined with essentially the same syntax as a normal one except for the "subscript" keyword? I want to give the benefit of the doubt about their being something "novel" about this feature, but the confusing name and the documentation being quite verbose without really giving much detail makes me feel like either the authors don't grasp that they're just giving a new name to something existing or that they purposely are trying to make it less obvious.
The subscript concept itself is nothing new, it is basically just a generalized element accessor, typically for collection types, arrays, dictionaries, etc.
it uses mostly the same sigils and syntax elements from C, like &, [], etc (the ${} is for string formatting, that in C is written %d, %lu etc - which is arguably worse)
for me the problem is that it changed the meaning of & gratuitously
I am unsure about the goals, but this is what the rule by the seld-elected judiciary was. When Israel's courts aligned themselves too far to the left and along the racial divide, they became incompatible with Israel's current demographics and majority-elected government. The catch is, the Israeli right wing may swing too far just as well.
“One flew over the cuckoo's nest” - back in the days, the state went a bit overboard with forced mental care, and there was a lot of political pressure to dismantle the system.
