digitalmars.dip.ideas - ternary op assign
- monkyyy (3/3) May 02 2024 `foo?=bar:baz` is rewritten as `foo.opOpAssign!("?:")(bar,baz)`
- Stefan Koch (3/6) May 02 2024 I find this syntax confusing, I would interpret that as:
- monkyyy (17/25) May 02 2024 often the statement you want to write is a=condition?b:a which
- Quirin Schroll (3/6) May 16 2024 Isn’t this just `if (!bar) foo = baz;`?
- monkyyy (7/15) May 16 2024 when bar depends on foo; such as a user defined cond, lets saya
- Walter Bright (1/1) Mar 15 Does this appear in other languages? I'm curious what experience there i...
- monkyyy (2/4) Mar 18 Not that I know of
- Salih Dincer (14/17) Mar 23 What will you do when you use ternary pipe?
- Salih Dincer (30/31) Mar 23 ```d
- monkyyy (25/54) Mar 23 Im imagining(if you like assign pass thru)
`foo?=bar:baz` is rewritten as `foo.opOpAssign!("?:")(bar,baz)`
`foo[i]?=bar:baz` opIndexOpAssign
for basic types it acts as `foo=(bool)bar?foo:(typeof(foo))baz`
May 02 2024
On Thursday, 2 May 2024 at 17:42:28 UTC, monkyyy wrote:
`foo?=bar:baz` is rewritten as `foo.opOpAssign!("?:")(bar,baz)`
`foo[i]?=bar:baz` opIndexOpAssign
for basic types it acts as `foo=(bool)bar?foo:(typeof(foo))baz`
I find this syntax confusing, I would interpret that as:
`foo[i] = (foo[i] ? bar : baz);`
May 02 2024
monkyyy <crazymonkyyy gmail.com> On Thursday, 2 May 2024 at 18:17:12 UTC, Stefan Koch wrote:On Thursday, 2 May 2024 at 17:42:28 UTC, monkyyy wrote:often the statement you want to write is a=condition?b:a which repeats a, the way to simplify (and prevent int promtion issues) is with the += family of statements; but there isnt a clear one for if(cond)a=b Simd(/waterfalled code) has to do bit mask tricks, and I think you could wrap that up in a data structure with the opslice as recursive templates for opindex logic ```d a/=4; b+=a; if(a>b)a=b; --- a[0..4]/=4; b[0..4]+=a[0..4]; ???? ````foo?=bar:baz` is rewritten as `foo.opOpAssign!("?:")(bar,baz)` `foo[i]?=bar:baz` opIndexOpAssign for basic types it acts as `foo=(bool)bar?foo:(typeof(foo))baz`I find this syntax confusing, I would interpret that as: `foo[i] = (foo[i] ? bar : baz);`
May 02 2024
On Thursday, 2 May 2024 at 17:42:28 UTC, monkyyy wrote:
`foo?=bar:baz` is rewritten as `foo.opOpAssign!("?:")(bar,baz)`
`foo[i]?=bar:baz` opIndexOpAssign
for basic types it acts as `foo=(bool)bar?foo:(typeof(foo))baz`
Isn’t this just `if (!bar) foo = baz;`?
Where would the user-defined operator be useful?
May 16 2024
On Thursday, 16 May 2024 at 16:57:17 UTC, Quirin Schroll wrote:On Thursday, 2 May 2024 at 17:42:28 UTC, monkyyy wrote:when bar depends on foo; such as a user defined cond, lets saya database query that takes in lamdas `foo?=a=>a%2:baz` and when its "multiable data single instruction", simd or parrellizism, ranges etc. and theres something in that index you can not write `if(!bar[foo's slice????]) foo=baz[...];``foo?=bar:baz` is rewritten as `foo.opOpAssign!("?:")(bar,baz)` `foo[i]?=bar:baz` opIndexOpAssign for basic types it acts as `foo=(bool)bar?foo:(typeof(foo))baz`Isn’t this just `if (!bar) foo = baz;`? Where would the user-defined operator be useful?
May 16 2024
Does this appear in other languages? I'm curious what experience there is with it.
Mar 15
On Sunday, 16 March 2025 at 06:45:03 UTC, Walter Bright wrote:Does this appear in other languages? I'm curious what experience there is with it.Not that I know of
Mar 18
On Thursday, 2 May 2024 at 17:42:28 UTC, monkyyy wrote:
`foo?=bar:baz` is rewritten as `foo.opOpAssign!("?:")(bar,baz)`
`foo[i]?=bar:baz` opIndexOpAssign
for basic types it acts as `foo=(bool)bar?foo:(typeof(foo))baz`
What will you do when you use ternary pipe?
```d
import std.stdio;
void main()
{
int x = 10, y = 20, z = 5;
string result = (x > y) ? "X is largest"
: (y > z) ? "Y is largest"
: "Z is largest";
result.writeln;
}
```
SDB 79
Mar 23
On Sunday, 23 March 2025 at 19:54:29 UTC, Salih Dincer wrote:What will you do when you use ternary pipe?```d import std.stdio; struct TernaryAssignable(T) { T value; // Implements `foo ?= bar : baz` ref T opOpAssign(string op)(T condition, T alternative) if (op == "?:") { if (condition) { return value; } else { return value = alternative; } } } void main() { auto foo = TernaryAssignable!int(42); int bar = 1; // true condition int baz = 100; // alternative value foo ?= bar : baz; // Equivalent to: foo = (bar ? foo : baz) writeln(foo.value); // Should print 42, since bar is nonzero (true) foo ?= 0 : baz; // Now foo should take baz since condition is false writeln(foo.value); // Should print 100 }``` Is it promising? SDB 79
Mar 23
On Sunday, 23 March 2025 at 19:59:24 UTC, Salih Dincer wrote:
```d
import std.stdio;
struct TernaryAssignable(T) {
T value;
// Implements `foo ?= bar : baz`
ref T opOpAssign(string op)(T condition, T alternative) if
(op == "?:") {
if (condition) {
return value;
} else {
return value = alternative;
}
}
}
void main()
{
auto foo = TernaryAssignable!int(42);
int bar = 1; // true condition
int baz = 100; // alternative value
foo ?= bar : baz; // Equivalent to: foo = (bar ? foo : baz)
writeln(foo.value); // Should print 42, since bar is
nonzero (true)
foo ?= 0 : baz; // Now foo should take baz since condition
is false
writeln(foo.value); // Should print 100
}
```
Im imagining(if you like assign pass thru)
```d
struct TernaryAssignable(T) {
T value;
// Implements `foo ?= bar : baz`
ref T opOpAssign(string op,S)(S condition, T alternative) if
(op == "?:") {
if ( ! condition(value)) {
return value;
} else {
return value = alternative;
}
}
}
bool isEmpty(string s)=>s.length==0;
bool hasAt(string s)=>s.canFind(' ');
bool hasDot(string s)=>true;//todo
string sanitizeEmail(ref TernaryAssignable!string s)=>
s ?= &isEmpty : "missingemail dlang.org"
?= &hasAt : s~" gmail.com"
?= &hasDot : s~".com";
unittest("".sanitizeEmail=="missingemail dlang.org");
unittest("crazymonkyyy gmail".sanitizeEmail=="crazymonkyyy gmail.com");
```
Mar 23