More Elegant Settable Methods?
Hi,
I am trying to create a struct with a settable method that has
access to the struct scope.
Is this the only way?
Is there a way to give access without explicitly passing `this`?
```d
import std.stdio;
struct TestStruct{
float /*--*/ a;
float /*--*/ b;
float function( TestStruct ) op;
float run(){
return op( this );
}
}
void main(){
TestStruct ts = TestStruct(
2,
3,
function( TestStruct s ){ return s.a + s.b; }
);
writeln( ts.run() );
}
```
Re: More Elegant Settable Methods?
Oops i clicked "Send" too fast
Re: More Elegant Settable Methods?
```D
TestStruct ts = {
a: 2, b: 3,
op: (s) {
return s.a + s.b;
}
};
```
This simple! just like with C's designated initializers
Re: More Elegant Settable Methods?
On Sunday, 22 January 2023 at 02:28:11 UTC, ryuukk_ wrote:
```D
TestStruct ts = {
a: 2, b: 3,
op: (s) {
return s.a + s.b;
}
};
```
This simple! just like with C's designated initializers
Ah, I had forgotten about this handy initializer form! However, I
may not have been clear. I was hoping that by assigning a
function as a member to a `TestStruct`, that it would already
have access to the other members of `TestStruct`. I can see now
that this would not pass muster during type checking and is
therefore a luxury afforded to dynamically typed languages only,
like Python:
```python
from types import MethodType
class TestStruct:
def __init__( self, A, B ):
self.a = A
self.b = B
def op( self ):
return self.a + self.b
ts = TestStruct(2, 3)
ts.op = MethodType(op, ts)
print( ts.op() )
```
Re: More Elegant Settable Methods?
On Saturday, 21 January 2023 at 23:07:45 UTC, jwatson-CO-edu
wrote:
I am trying to create a struct with a settable method that has
access to the struct scope.
Is this the only way?
Is there a way to give access without explicitly passing `this`?
Why not use the delegate? What exactly do you want to do? Set
after constructor or assign delegate?
```d
struct S {
float /*--*/ a;
float /*--*/ b;
void delegate(float x, float y) set;
auto sum() { return a + b; }
}
void main() {
S s;
s.set = (x, y) {
s.a = x;
s.b = y;
};
s.set(10, 20);
assert(s.sum == 30);
}
```
SDB@79
Re: More Elegant Settable Methods?
On Monday, 30 January 2023 at 07:48:09 UTC, Salih Dincer wrote:
On Saturday, 21 January 2023 at 23:07:45 UTC, jwatson-CO-edu
wrote:
I am trying to create a struct with a settable method that has
access to the struct scope.
Is this the only way?
Is there a way to give access without explicitly passing
`this`?
Why not use the delegate? What exactly do you want to do? Set
after constructor or assign delegate?
```d
struct S {
float /*--*/ a;
float /*--*/ b;
void delegate(float x, float y) set;
auto sum() { return a + b; }
}
void main() {
S s;
s.set = (x, y) {
s.a = x;
s.b = y;
};
s.set(10, 20);
assert(s.sum == 30);
}
```
SDB@79
So `delegate` looks closer to what I want. I am looking to
implement a [Strategy
Pattern](https://en.wikipedia.org/wiki/Strategy_pattern) in which
I have an object with an update method which is settable at
runtime, either during instantiation or after. The function you
have assigned to `set` has access to the `S` object, just like I
had wished; Thank you!
The application is a [Braitenberg
Vehicle](https://en.wikipedia.org/wiki/Braitenberg_vehicle)
environment. There are a more than a few component types that
are connected to each other in the same way and pass messages of
a consistent type. I'd like not to write a struct/class for each
component type; but rather write their common structure once and
set their type-specific behavior as they are created.
It looks like I can write a function for each component type and
assign a `delegate` update strategy after the common struct has
been created. This is what I had asked for. Thank you for this
lesson.
