www.digitalmars.com         C & C++   DMDScript  

digitalmars.D.learn - Comparing slices with std.variant.Algebraic

reply anonymouse <anony mouse.com> writes:
Observe the 
[implementation](https://github.com/Kriyszig/magpie/blob/master/s
urce/magpie/axis.d) of
```d
stuct Axis(U...){}
```

More specifically, observe its usage in the unittests for [Binary 
Ops on Variant 
Axis](https://github.com/Kriyszig/magpie/blob/master/source/magp
e/axis.d#L410-L437) and [Binary Ops on Variant + Other
DataType](https://github.com/Kriyszig/magpie/blob/master/source/magpie/axis.d#L440-L467)

Note that both tests fail due to asserts on lines 422 and 452. 
Note also that commenting out these two lines results in 
successful compilation of all other tests. Inspecting c.data, one 
will find that it holds the array [1.7, 3.7, 5.7, 7.7, 9.7] in 
both cases, which is what is being asserted by those two lines.

So the question is, what is the proper way to compare a slice 
(array literal?) and an Algebraic in current D? I assume that 
this code worked back in 2019, however, I am unable to detect 
when it stopped working because no DMD compiler prior to v2.100.0 
works properly on my system.

On a related note, std.variant.Algebraic has been deprecated and 
the suggested replacement is std.sumtype.SumType. What is the 
proper way to make this conversion? Attempting to do a drop-in 
replacement results in the following errors:

```
axis.d(400): Error: incompatible types for array comparison: 
`SumType!(bool, int, long, float, double, string, DateTime)[]` 
and `double[]`
axis.d(86): Error: incompatible types for `(this.data[i]) + 
(rhs.data[i])`: both operands are of type `SumType!(bool, int, 
long, float, double, string, DateTime)`
axis.d(414): Error: template instance 
`axis.Axis!void.Axis.opBinary!("+", void)` error instantiating
axis.d(86): Error: incompatible types for `(this.data[i]) + 
(rhs.data[i])`: `SumType!(bool, int, long, float, double, string, 
DateTime)` and `int`
axis.d(445): Error: template instance 
`axis.Axis!void.Axis.opBinary!("+", int[])` error instantiating
axis.d(43): Error: none of the overloads of template `object.get` 
are callable using argument types `!(int)(const(SumType!(bool, 
int, long, float, double, string, DateTime)))`
/Users/anonymouse/dlang/dmd-2.100.0/osx/bin/../../src/druntime/im
ort/object.d(3409):        Candidates are: `get(K, V)(inout(V[K]) aa, K key,
lazy inout(V) defaultValue)`
/Users/anonymouse/dlang/dmd-2.100.0/osx/bin/../../src/druntime/im
ort/object.d(3416):                        `get(K, V)(inout(V[K])* aa, K key,
lazy inout(V) defaultValue)`
axis.d(47): Error: none of the overloads of template `object.get` 
are callable using argument types `!(double)(const(SumType!(bool, 
int, long, float, double, string, DateTime)))`
/Users/anonymouse/dlang/dmd-2.100.0/osx/bin/../../src/druntime/im
ort/object.d(3409):        Candidates are: `get(K, V)(inout(V[K]) aa, K key,
lazy inout(V) defaultValue)`
/Users/anonymouse/dlang/dmd-2.100.0/osx/bin/../../src/druntime/im
ort/object.d(3416):                        `get(K, V)(inout(V[K])* aa, K key,
lazy inout(V) defaultValue)`
axis.d(474): Error: template instance 
`axis.Axis!void.Axis.convertTo!(int[])` error instantiating
axis.d(43): Error: none of the overloads of template `object.get` 
are callable using argument types `!(double)(const(SumType!(bool, 
int, long, float, double, string, DateTime)))`
/Users/anonymouse/dlang/dmd-2.100.0/osx/bin/../../src/druntime/im
ort/object.d(3409):        Candidates are: `get(K, V)(inout(V[K]) aa, K key,
lazy inout(V) defaultValue)`
/Users/anonymouse/dlang/dmd-2.100.0/osx/bin/../../src/druntime/im
ort/object.d(3416):                        `get(K, V)(inout(V[K])* aa, K key,
lazy inout(V) defaultValue)`
axis.d(47): Error: none of the overloads of template `object.get` 
are callable using argument types `!(double)(const(SumType!(bool, 
int, long, float, double, string, DateTime)))`
/Users/anonymouse/dlang/dmd-2.100.0/osx/bin/../../src/druntime/im
ort/object.d(3409):        Candidates are: `get(K, V)(inout(V[K]) aa, K key,
lazy inout(V) defaultValue)`
/Users/anonymouse/dlang/dmd-2.100.0/osx/bin/../../src/druntime/im
ort/object.d(3416):                        `get(K, V)(inout(V[K])* aa, K key,
lazy inout(V) defaultValue)`
axis.d(478): Error: template instance 
`axis.Axis!void.Axis.convertTo!(double[])` error instantiating
```

Thanks,
--anonymouse
Sep 05 2022
next sibling parent reply =?UTF-8?Q?Ali_=c3=87ehreli?= <acehreli yahoo.com> writes:
On 9/5/22 01:58, anonymouse wrote:


 array [1.7, 3.7, 5.7, 7.7, 9.7] in both cases, which is what is being
 asserted by those two lines.


None of those values can be represented precisely in a floating point 
type. Without looking at the code, I wonder whether the tests will pass 
if you can manage to use the following values instead, which can be 
represented precisely:

   [1.5, 3.5, 5.5, 7.5, 9.5]

Ali
Sep 05 2022
parent anonymouse <anony mouse.com> writes:
On Monday, 5 September 2022 at 10:30:32 UTC, Ali Çehreli wrote:

 On 9/5/22 01:58, anonymouse wrote:


 array [1.7, 3.7, 5.7, 7.7, 9.7] in both cases, which is what


 is being

 asserted by those two lines.


 None of those values can be represented precisely in a floating 
 point type. Without looking at the code, I wonder whether the 
 tests will pass if you can manage to use the following values 
 instead, which can be represented precisely:

   [1.5, 3.5, 5.5, 7.5, 9.5]

 Ali


It will not.

--anonymouse
Sep 05 2022
prev sibling parent reply Paul Backus <snarwin gmail.com> writes:
On Monday, 5 September 2022 at 08:58:21 UTC, anonymouse wrote:

 On a related note, std.variant.Algebraic has been deprecated 
 and the suggested replacement is std.sumtype.SumType. What is 
 the proper way to make this conversion? Attempting to do a 
 drop-in replacement results in the following errors:

 ```
 axis.d(400): Error: incompatible types for array comparison: 
 `SumType!(bool, int, long, float, double, string, DateTime)[]` 
 and `double[]`
 axis.d(86): Error: incompatible types for `(this.data[i]) + 
 (rhs.data[i])`: both operands are of type `SumType!(bool, int, 
 long, float, double, string, DateTime)`
 axis.d(414): Error: template instance ```


`SumType` does not attempt to forward operators to the contained 
value like `Algebraic` does, so you will have to use 
[`tryMatch`][1] to access the value(s) in cases like these.

```d
// Compare a DataType[] to a double[]

import std.algorithm.comparison: equal;

/+
Will throw an exception if lhs contains a value that can't
be compared to a double.
+/
alias cmp = (DataType lhs, double rhs) => lhs.tryMatch!(value => 
value == rhs);

DataType[] a;
double[] b;
bool result = a.equal!cmp(b);
```

```d
// Add two DataType values

/+
addValues will take two DataTypes as arguments and match on
both simultaneously.

If the two DataTypes do not contain values that can be added
together, an exception will be thrown.

See:
- https://dlang.org/phobos/std_sumtype.html#multiple-dispatch
- 
https://dlang.org/phobos/std_sumtype.html#introspection-based-matching
+/
alias addValues = tryMatch!((lhs, rhs) => lhs + rhs);

DataType a;
DataType b;
DataType result = addValue(a, b);
```

[1]: https://phobos.dpldocs.info/std.sumtype.tryMatch.html
Sep 05 2022
parent anonymouse <anony mouse.com> writes:
Thanks Paul. Gotta wrap my head around this well enough to update 
that module. However, this is a great start. Thank  you very much.

--anonymouse
Sep 07 2022