Operators?

Sizeof?

The sizeof operator is designed for working with off heap memory. It provides us an indication of the size in bytes that any object (including arrays) will consume when serialized into a byte format as par the scheme referenced within its optional qualifier. For example, when working on the gpu we can use a qualifier as follows:

leAr = [1 2 3 4 5 6 7 8 9 10]
gpusize = sizeof<gpus.gpusizeof> leAr//size of leAr on the gpu

If no qualifier is provided then the default off heap serialization built into Concurnas is used:

leAr = [1 2 3 4 5 6 7 8 9 10]
gpusize = sizeof leAr//size of leAr as par default scheme

def sizeofCustomScheme(some Object) int{
  //some logic...
  return 1//in this example every object is 1 byte large
}

Contains?

The contains class of operator consists of two variants, in and not in. in can be used with common data collection structures including: lists, sets and arrays to test to see if a value on its left hand side is within the expression of one of the aforementioned data structures on the right hand side. If it's present a boolean value of true is returned, otherwise false. not in returns true if the value on the left is not present within the data structure.

alist = [1,2,3,4,5]
within = 2 in alist

in may be used in a similar way with maps in order to examine whether a key is present within the map. For example:

amap = {2 -> 23, 3 -> 67. 1 -> 55}
within = 2 in amap

The in keyword has special meaning when used within the context of an iterator style for loop, this is documented in the Iterator style for section.

Not?

The not keyword simply flips the booleanarity of a value of boolean type. true becomes false and vice versa.

Postfix?

Concurnas supports the usual set of postfix operators one would expect from a modern programming language. Namely the increment ++ and decrement -- operators appearing on the right hand side of an integral expression consisting of a variable, list or array reference. These operators are applied in place. The operators may be used in a place where a value is expected to be returned from it, in which case the previous value of the variable prior to the increment or decrement operator being applied will be returned:

avar = 10
anarray = [1 2 3 4 5]

avar++
anarray[0]--

prevvar = avar++
prevarray = anarray[0]--

Prefix?

The prefix operators behave in a similar manner as the postfix operators though with the addition of the negation: - operator. Unlike the others, the negation: - operator is not applied in place and will always return a value. The operators may be used in a place where a value is expected to be returned from it, in which case the value of the variable post operator application will be returned:

avar = 10
anarray = [1 2 3 4 5]

++avar
--anarray[0]

newvar = ++avar
newarray = --anarray[0]

anothervar = 10
negative = -anothervar//negative == -10

Multiplicative?

Concurnas supports the standard set of multiplicative operators which can act upon two, potentially differing, integral types, multiplication: *, division: /, power: ** and modulus: mod. For example:

mul = 3*2 //==6
div = 12/2 //==6
pow = 3**2 //==9
pow = 9**-2 //square root
modu = 10 mod 4 //==2

Attempting to divide by zero with two non floating point (either float or double) values will result in an exception of type java.lang.ArithmeticException being thrown. Attempting to divide by zero with at least one floating point value will result in: Infinity being returned. 0./0. will resolve to NaN.

In situations where the left and right types of the multiplicative operator differ, the more general type shall be used for the return type. For example:

div1 = 13/2f //==6.5 (float)
div2 = 13/2. //==6.5 (double)
div3 = 13f/2. //==6.5 (double)
mulong = 100*10L //1000L (long)
mulong = 100L*10. //1000. (double)

assert 13/2 == 6.5 //fails!

assert 13./2 == 6.5 //expected asnwer

Additive?

Concurnas supports addition: + and subtraction -. These are straightforward and the rules concerning generalization of numerical types as par the multiplicative operators above apply. Examples:

addition = 1+1
subtraction = 1-1

Additionally, the addition operator + can be used for String concatenation. This is described in more detail in the The String concatenation operator \lstinline!+! section.

Bitshift?

Concurnas supports bit shift operators for integral types. They operate on a bit pattern, given by the left hand operand and a number of positions to shift by the right hand operand.

• << - Left shift. Shifts a bit pattern to the left.

• >>> - Unsigned right shift. Shifts a bit pattern to the right. Shifts a zero to the leftmost position.

• >> - Right shift. Shifts a bit pattern to the right. Leftmost bit is shifted contingent on sign extension.

Example:

def shifty(){
  a = 17
  x1 = a << 2
  x2 = a >> 2
  x3 = a >>> 2
  [x1, x2, x3]
}

shifty() //resolves to => [68, 4, 4]

Relational?

The main relational operators in Concurnas are less than: <, greater than: >, less than or equal:<== and greater than or equal: >==. These operate upon two integral types. And return a boolean type. Examples:

lt = 1 < 2
gt = 3 > 2
lteq = 1 <== 2
gteq = 3 ==> 2

Instance of and Cast?

The instance of or cast operators may not be overloaded. They are covered in more detail in theCasting and Checking Types chapter.

Equality?

Concurnas supports two variants of equality, structural equality (as: equal: == and not equal: <>) and referential equality (denoted by prefixing the equality operator with an ampersand: &). The structural equality operators may operate upon any type, whereas the referential quality operators may only operate upon Objects. For all operator variants, they return a boolean value indicating equality. Let's look at some examples of structural equality:

eq = 10 == 10 //true
eq2 = 10 <> 12 //true
eq3 (1>3) == false //resolves to true

When it comes to structural equality for objects this is achieved by calling the equals method on the left hand side object and passing it the object on the right hand side as an argument. Note that in Concurnas this equality method is automatically created for all Objects and it resolves to provide structural equality, this behaviour can be user overridden to provide different behaviour. More details of this can be found in the Automatically generated equals and hashcode methods section. Examples:

class Person(name String)

d1 = Person('dave')
d2 = Person('dave')
f3 = Person('freddy')

assert d1 == d2 //struturally equal
assert d1 <> f3 //struturally not equal
assert d1 &== d1 //object is referentially equal to itself!
assert d1 &<> d2 //d1 and d2 though structurally equal (above) are not referentially equal

Bitwise operators?

The major bitwise operators take two integral types as input. The following operators are supported:

• band - bitwise and

• bor - bitwse or

• bxor - bitwise exclusive or

These operators are commonly used in order to apply masks. Example:

def pprint(xx int) => '0x' + String.format("%8s", Integer.toBinaryString((xx+256) % 256)).replace(" ", "0")

value = 0b00010101
bitmask = 0b00000001

pprint(value band bitmask) // -> 0x00000001
pprint(value bor bitmask)// -> 0x00010101
pprint(value bxor bitmask)// -> 0x00010100

orig byte = 0b00000011
complement= comp orig

Integer.toBinaryString((complement+256) % 256) // resolves to: '11111100' - which is the complement of the input byte.

Logical and/or?

Concurnas supports the logical and and or operators which can be used in order to chain together boolean expressions. Naturally, both arguments to these operators must be of boolean type. More then one and or or may be chained together. The operators both return boolean values. Examples:

orand1 = 2 == 3 or 3>1
orand2 = 2 == 3 or 3>1 or 22>1 or 3 < 9
orand3 = 2>1 and 4>1

def eval1(toRet boolean) => toRet
def eval2(toRet boolean) => toRet
def toCall(toRet boolean) => toRet

shortcir = eval1(false) or eval1(true) or toCall(true)//toCall will never be called!
shortcir = eval1(true) and eval1(false) and toCall(true)//toCall will never be called!

Ternary?

The Ternary operator x if test else z can be thought of as a handy shorthand for the slightly more verbose: if(test){ x }else{ z } (in fact, under the hoot the Ternary operator is translated into this more verbose form). x and z must both return a value (of any type) and test must resolve to a value of boolean type. Example:

def test() => true

result = 12 if test() else 99

Invoke?

Concurnas allows an invoke method to be defined for all objects, this permits the following syntax to be used in order to call this invoke method as an operator, with optional arguments:

class FormatPlus{
  def invoke(a int, b int) => "{a} + {b}"
}

fmt = FormatPlus()
fmt(12, 13)//returns: "12 + 13"

This can occasionally be useful tool to use when defining domain specific languages.

Null safety?

The null safety operators are documented in detail in the Null Safety section.

Parentheses?

In Concurnas, parentheses can be used or order disambiguate expressions composed of multiple operators. They may also be used in a "no operation" capacity in order to make code easier to read. For example:

orand4 = not (2>1 and 4>1)