Operator overloading (hello, php)

[nerobotParticipant]

I’m working with PHP last time, and there is a nice array syntax:

arr[] = "hello";

that means append the string to array.

I tried to achive that in Monkey2.

Monkey

Class Arr Operator[]=( key:String=Null,val:Variant ) End Operator[]:Variant( key:String ) End End

1 2 3 4 5 6 7 8 9 10 11

Class Arr Operator[]=( key:String=Null,val:Variant ) End Operator[]:Variant( key:String ) End End

I set default value of key to Null hoping to be able to omit key, but with no luck:

Monkey

arr[] = "hello"

1	arr[] = "hello"

result is:

Error : Expecting expression but encountered ']'

It’s impossible, I think, and looks like just as academic try.

[coconParticipant]

You refer to this one right?
http://php.net/manual/en/function.array-push.php

From what I have tested up until now, in Monkey the operator [] as a language construct is specified to work as an indexer (which is similar to a C# concept). http://monkeycoder.co.nz/forums/topic/some-indexers-for-lists/

You can think of the indexer function signatures (if you assume that there is no operators at all) similar to this:

Monkey

Function IndexerOnly<T2>:T1(t1:T1) Function IndexerWithEquals<T1, T2>(t1:T1, t2:T2)

1 2	Function IndexerOnly<T2>:T1(t1:T1) Function IndexerWithEquals<T1, T2>(t1:T1, t2:T2)

Where in this example you can see how this concept would possible work, but be aware that this is only an example for the Joy-Of-API-Hacking and satisfy the compiler.

Monkey

#Import "<std>" Using std.. Struct SupaString Field TheString:String Operator[]=(key:Bool, value:String) ' normally you would overload the "key" parameter with key:Bool=False ' but in this case it's a restriction of the [] operator ' that really needs a value inside the [] operator If key TheString += value Else TheString = value End End Operator[]:String(key:String=False) Return TheString End End Function Main() Local supa := New SupaString supa[False] = "Hello World" supa[False] = "Super Duper" ' false key will replace supa[True] = " String" ' true key will append supa[True] = " Is The Best" Print(supa[False]) End

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36

#Import  "<std>" Using std..   Struct SupaString Field TheString:String Operator[]=(key:Bool, value:String) ' normally you would overload the "key" parameter with key:Bool=False ' but in this case it's a restriction of the [] operator ' that really needs a value inside the [] operator   If key TheString += value Else TheString = value End End Operator[]:String(key:String=False) Return TheString End End   Function Main() Local supa := New SupaString supa[False] = "Hello World" supa[False] = "Super Duper" ' false key will replace supa[True] = " String"      ' true key will append supa[True] = " Is The Best" Print(supa[False]) End

 

Also for the record, @hezkore found a way of changing the fundamental datatypes, perhaps you would be interested to see how you can change the meaning of the [] operator with this one, I haven’t tried something like this yet to be sure but it seems interesting.
https://github.com/Hezkore/m2stp/blob/master/inc/base_functions.monkey2

[Mark SiblyKeymaster]

that means append the string to array.

It sure doesn’t look like it!

This would require major changers to the parser though, as ‘[]’ is not a valid ‘value expression’ (it may only appear in type expressions, ie: when declaring the type of something).

How about ‘+=’ instead? This looks much more logical to me.

[nerobotParticipant]

You refer to this one right?

Yes. Your example is not good enough because I want to omit the key at all.

Also, if you pass False as a string parameter, you’ll get the string “False”, not an empty string,

and expression If key then... always be true.

I think you mean to pass Null here.

 

How about ‘+=’ instead? This looks much more logical to me.

It seems to be the only way here.

Brackets show us we deal with array, but += don’t.

But I don’t expect to break parser and our minds just because the PHP syntax.

[Mark SiblyKeymaster]

Brackets show us we deal with array, but += don’t.

That’s about all it shows. The syntax ‘[]=’ to append to an array is typical php WTF-ness!

But I did have a quick look at the parser and, I sort of hate to say it, but it’s actually a pretty simple tweak to allow no args for array indexing. With a 2 line change to parser.monkey2 I can compile this…

Monkey

Class C Operator[]=( key:String,value:String ) Print "key="+key+", value="+value End Operator[]=( value:String ) Print "value="+value End End Function Main() Local c:=New C c["one"]="two" c[]="Hello there!" End

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

Class C Operator[]=( key:String,value:String ) Print "key="+key+", value="+value End Operator[]=( value:String ) Print "value="+value End End   Function Main() Local c:=New C c["one"]="two" c[]="Hello there!"   End

…which isn’t quite what you wanted, but enough to be able to do what you want I believe?

I still really dislike []= to append to an array though, boring old Method Add() is IMO a much better option!

[nerobotParticipant]

Wow, good news!

When you omit key it passes as Null ?

[DiffrenzyKeymaster]

That’s about all it shows. The syntax ‘[]=’ to append to an array is typical php WTF-ness!

I agree. += is nice though.

[nerobotParticipant]

I’m thinking about assignment operator, again

And it would be enough for me to have []= operator as a special kind of assignment.

Monkey

Function Main() Local t:=New Test<Float> ' special kind of assignment ' equals to t.value=3.0 t[]=3.0 ' special king of return value ' equals to 10+t.value Local sum:=10+t[] Print t.value End Class Test<T> Field value:T Operator []=( value:T ) Self.value=value End Operator []:T( i:Int=0 ) Return Self.value End End

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29

Function Main()   Local t:=New Test<Float> ' special kind of assignment ' equals to t.value=3.0 t[]=3.0 ' special king of return value ' equals to 10+t.value Local sum:=10+t[] Print t.value End   Class Test<T> Field value:T Operator []=( value:T ) Self.value=value End Operator []:T( i:Int=0 ) Return Self.value End End

This time both of these operators don’t work.

and this sounds interesting:

With a 2 line change to parser.monkey2 I can compile this

What are anyone think about it?:)

As for me – it could be a part of language, we don’t need to use it every time…

[Mark SiblyKeymaster]

Yeah, nah…

Sorry, but it still looks kind of nasty to me. And aren’t you gonna  confuse a whole bunch of php users?!?

I’m probably not quite as adverse to overloading ‘=’ as I used to be though. I assume the goal here is still to achieve ‘property changed’ events/signals?

I mean, you can already do this quite easily:

Monkey

Class MyLife Field LifestyleChanged:Void() Property Lifestyle:Int() Return _lifestyle Setter( lifestyle:Int ) If lifestyle=_lifestyle Return _lifestyle=lifestyle LifestyleChanged() End Private Field _lifestyle:Int End

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

Class MyLife Field LifestyleChanged:Void() Property Lifestyle:Int() Return _lifestyle Setter( lifestyle:Int ) If lifestyle=_lifestyle Return _lifestyle=lifestyle LifestyleChanged() End   Private Field _lifestyle:Int End

…but of course you know this! If the goal is to wrap both the signal and the setter/getter in a single concept, you can do this too, eg:

Monkey

Struct MyProperty<T> Field Changed:Void() Method Set(value:T) If value=_value Return _value=value Changed() End Method Get:T() Return _value End Private Field _value:T End Class MyLife Field Lifetyle:MyProperty<Int> End

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

Struct MyProperty<T> Field Changed:Void() Method Set(value:T) If value=_value Return _value=value Changed() End Method Get:T() Return _value End Private   Field _value:T End   Class MyLife Field Lifetyle:MyProperty<Int> End

This is effectively what your (mostly) doing above, except you need to use Lifestyle.Set() and Lifestyle.Get() to set/get the value, plus you can listen for changes using Lifestyle.Changed+=Lamba…

IMO, the []= syntax isn’t enough of an improvement over plain Set and Get here to justify it. In fact I’d argue Get and Set is much clearer than an ‘array looking’ operator. And either way, the programmer has to ‘know’ to use it (if you see what I mean).

Overloading ‘=’ is much more interesting though – it means ‘live’ properties like this could be added to existing code without user code knowing it wasn’t just reading/writing files/properties. But for this work, there’d also have to be a ‘conversion’ operators for reads. Perhaps something like:

Monkey

Struct MyProperty<T> Field Changed:Void() Operator Setter( value:T ) If value=_value Return _value=value Changed() End Operator Getter:T() Return _value End Private Field _value:T End Class MyLife Field Lifetyle:MyProperty<Int> End

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

Struct MyProperty<T> Field Changed:Void() Operator Setter( value:T ) If value=_value Return _value=value Changed() End Operator Getter:T() Return _value End Private   Field _value:T End Class MyLife Field Lifetyle:MyProperty<Int> End

But alas we’ve already hit our first complication! If the ‘type’ of Lifestyle is Int thanks to its getter operator, how can we access Lifestyle.Changed?

And if T is a class/struct, what does Lifestyle.blah mean? Is it a member of Lifestyle, or a member of LifeStyle.Getter? The compiler could attempt to guess what you want to do, but it’d likely result in a bunch of confusing rules, and type conversions would be a nightmare when calling functions, assigning to vars etc. And what happens with prop1=prop2? If they are both Int Getters of the same type, should it get/set the int, or assign the entire getter, ‘Changed’ listeners and all? The sensible thing to do in all these cases is probably to treat any value  with a Getter as a value of the Getters type instead (just like properties),  and add new syntax to somehow ‘ignore’ the getter when you want work with the actual property-like container.

All in all it’s an interesting idea and I think it could be made to work, will keep thinking about it….

[nerobotParticipant]

And aren’t you gonna  confuse a whole bunch of php users?!?

agree, it’s very bad idea.

If the ‘type’ of Lifestyle is Int thanks to its getter operator, how can we access Lifestyle.Changed?

yes! it’s looks impossible, and I miss it in my minds, if we have getter that return any type – we cant easily access to our parent type,

the way via casting is not what we want.

And what happens with prop1=prop2? If they are both Int Getters of the same type, should it get/set the int, or assign the entire getter, ‘Changed’ listeners and all? The sensible thing to do in all these cases is probably to treat any value  with a Getter as a value of the Getters type instead (just like properties),  and add new syntax to somehow ‘ignore’ the getter when you want work with the actual property-like container.

I expected to have type conversion for expressions with our type, but not for dot access case, but I see now that it’s kind of impossible.

Even if we’ll have assignment operator we’ll have no proper get operator and need to write getter explicitly:

Monkey

Local prop:=New Property<String> prop="hello" Local s:=prop.Value ' or prop.Get()

1 2 3

Local prop:=New Property<String> prop="hello" Local s:=prop.Value ' or prop.Get()

Operator To:T can help in some cases but not all.

And I think now that using explicit prop.Value for setter and getter is the best solution.

Thanks for the detailed answer, Mark!

[coconParticipant]

Something else theoretical, if we had the ability to declare custom operators as in Haskell, we would simply use them in interesting ways.

 

As for example let’s say we would like to have the initial idea of nerobot to append strings. We would write this pure function, “pure” means that the function is stateless (state-independent).

Monkey

Function AppendString:String(from:String, to:String) Return from + to End

1 2 3

Function AppendString:String(from:String, to:String)     Return from + to End

OK, we might consider that this code is dump pointless . Now taking concept further we would avoid this once and for all and use this instead.

This is the type signature. (+++) :: String -> String -> String And now here in MonkeyHaskell 🙂 here is the function declaration. Function (+++) : String(a:String, b:String) Return a + b End And then we would use the custom operator, either as Prefix (before terms) notation or Infix (inbetween terms) (+++) "Hello" "Monkey" "Hello" (+++) "Monkey"

1 2 3 4 5 6 7 8 9 10 11 12

This is the type signature. (+++) :: String -> String -> String   And now here in MonkeyHaskell here is the function declaration. Function (+++) : String(a:String, b:String)   Return a + b End   And then we would use the custom operator, either as Prefix (before terms) notation or Infix (inbetween terms) (+++) "Hello" "Monkey" "Hello" (+++) "Monkey"

The general idea of using custom operators is to reduce “verbose” syntax. Instead of having a pumped API that makes you bored to hell to use it. You would cleverly create important domain operations and thus create such shortcuts.

[Author]

Posts