Operator Methods - Revision history

Adamcolton at 14:11, 23 September 2019

2019-09-23T14:11:42Z

← Older revision		Revision as of 14:11, 23 September 2019
Line 10:		Line 10:
	* logical/bitwise (and, or, not, xor, nor)		* logical/bitwise (and, or, not, xor, nor)
	* bit (<< >>)		* bit (<< >>)
			* compare (<, =<, ==, !=, >=, >)

	One type cannot define both Concat and Add/Positive.		One type cannot define both Concat and Add/Positive.
Line 20:		Line 21:

	For many of these types, function can return two values. For instance on +, the second value is an ok that will return false if the addition overflowed the type.		For many of these types, function can return two values. For instance on +, the second value is an ok that will return false if the addition overflowed the type.

			== Limits ==
			It may make sense to limit operator overloading to libraries. The thought being that modules are intended for application (business) logic. These should not be doing complex things.

			One counter to this is that we may want to sort, so we may want compare.

	[[Category:Gryphon]]		[[Category:Gryphon]]

Adamcolton at 17:28, 17 September 2019

2019-09-17T17:28:24Z

← Older revision		Revision as of 17:28, 17 September 2019
Line 20:		Line 20:

	For many of these types, function can return two values. For instance on +, the second value is an ok that will return false if the addition overflowed the type.		For many of these types, function can return two values. For instance on +, the second value is an ok that will return false if the addition overflowed the type.

			[[Category:Gryphon]]

Adamcolton: Created page with "Types can have operator methods. Operators always follow the same precedence and must be immutable. Operators * Add (+Add) * Positive (+Positive) * Concat (+Concat) * Subtrac..."

2019-09-17T17:27:39Z

Created page with "Types can have operator methods. Operators always follow the same precedence and must be immutable. Operators * Add (+Add) * Positive (+Positive) * Concat (+Concat) * Subtrac..."

New page

Types can have operator methods. Operators always follow the same precedence and must be immutable.

Operators
* Add (+Add)
* Positive (+Positive)
* Concat (+Concat)
* Subtract (-Sub)
* Negate (-Neg)
* Index ([])
* logical/bitwise (and, or, not, xor, nor)
* bit (<< >>)

One type cannot define both Concat and Add/Positive.

I'm not sure about type enforcement. It would be clean to say that both inputs to an operator must be the same time (what V does). But that doesn't always work, for instance, you can't add two points. So it might make more sense to have Mathematical compliance. So you must have the following consistency
* A+B=C
* B=C-A
* A=C-B
And probably more into multiplication and exponentiation.

For many of these types, function can return two values. For instance on +, the second value is an ok that will return false if the addition overflowed the type.