Shadow

When designing Shadow, we wanted to keep syntax as familiar as possible to ease the learning curve. On the other hand, we thought we could do some things more cleanly or more safely. The features below describe some of the syntax that gives Shadow its distinctive flavor.

Have you ever wanted to write a method that returns multiple things? Of course you have! C gets around the problem by passing pointers. C++ gets around the problem with pass-by-reference parameters. Similarly, C# has reference and output parameters. Java has no good solution, forcing hacks like returning an object created just for the occasion or passing in small arrays to simulate pass-by-reference.

Shadow uses the same sequence syntax to return multiple values and to store them into variables after the return. The following is a toy method that returns both the quotient and the remainder of a division.

public divide(int a, int b) => (int, int)
{
	int quotient = a / b;
	int remainder = a % b;
	return (quotient, remainder);
}

Note the slightly different method syntax that puts all return types on the right side of the method header. A method that returns nothing leaves those parentheses empty. Presto! The void keyword is no longer needed. Calling the method behaves the same as any sequence assignment.

(result, modulus) = divide(7, 3); // stores 2 and 1, respectively

If you don’t need to store one of the values, just leave it out of the list.

(result, ) = divide(7, 3); // only stores 2

In Java and C#, the plus (+) operator is used to concatenate other types onto string values. Because the plus operator is used for numerical operations, its use can be ambiguous.

// Java code
String song1 = "Love Potion Number " + 4 + 5;
String song2 = "Love Potion Number " + (4 + 5);

Since Java concatenation has the same precedence as normal addition, song1 contains "Love Potion Number 45" while song2 contains "Love Potion Number 9". Our solution was to use the octothorpe (#), now commonly called the pound sign, number sign, or hash tag, as a string concatenation operator. This operator, called cat in Shadow jargon, has a lower precedence than addition.

// Shadow code
String song1 = "Love Potion Number " # 4 + 5;

In this Shadow version, song1 contains "Love Potion Number 9". There is also a unary version of cat, which is equivalent to calling the toString() method on any object.

Bottle bottle = sea.washUp();
String message = #bottle;

There is no static keyword in Shadow, but in other languages it is occasionally necessary to use a static member to share a single item among many pieces of code. Perhaps the best reason to do so is the singleton design pattern, in which there is only ever a single object of a given class. Our solution is singleton classes, of which there can only be a single object at any time, per thread.

A singleton object never needs to be created, since its creation is handled in the first method where it appears. A good example of a singleton is the Console class used for command line I/O. Although not necessary, a singleton variable can be used, which is just a convenient alias for the singleton.

Console out; // No create needed (or possible)
out.printLine("Bring rap justice!");
Console screen; // Still the same object
screen.printLine("Shut 'em down!");

What happens when you want to make a copy of an object? You can store the object into another reference, but that only creates an alias for the same object, not a copy.

All objects in Java have a clone() method, which allocates a new object and copies over all of its members. Unfortunately, its operation depends on everyone implementing the clone() method correctly for every class. Many developers do not implement the clone() at all. Likewise, the clone() method often cannot perform a true deep copy, in which all the members of the object are also copied. The risk in doing so would be the presence of a circular reference, which would begin a cycle of copying that would never finish.

In Shadow, there are two keywords specifically designed for deep copies: copy and freeze. When copy is used to copy an object, it performs a full deep copy, making deep copies of all the members as well. Internally, the copy command keeps track of all the new objects allocated. If a circular reference would cause something to be copied a second time, the copy command instead uses the first copy. The exception to the rule is immutable objects, which cannot be changed anyway. References to such objects are assigned directly, without making copies of the underlying objects.

The freeze command works exactly like the copy command except that all of the copies it creates are immutable. The freeze command is the only way to create an immutable version of an existing object whose class is not already immutable.

Person stanleyBurrell = Person:create("Stanley Kirk Burrell");
Person mcHammer = copy(stanleyBurrell);
mcHammer.setName("MC Hammer"); // Doesn't affect stanleyBurrell
immutable Person cantTouchThis = freeze(mcHammer); // Can never have its internals changed

In effect, the discussion above demonstrates a kind of operator overloading for the == operator; however, operator overloading is a slippery slope. In our opinion, C++ went overboard, allowing even fundamental operators like assignment (=) to be overloaded in arbitrary ways.

The Shadow approach is limited and based on interfaces. For overloading arithmetic operators, the interfaces CanAdd<T>, CanSubtract<T>, CanMultiply<T>, CanDivide<T>, and CanModulus<T> can be implemented to allow overloading of the +, -, *, /, and % operators, respectively. Below is an example of a Complex class for manipulating complex numbers that overloads +, -, and *.

immutable class Complex
is  CanAdd<Complex> 
and CanSubtract<Complex>
and CanMultiply<Complex>
and CanEqual<Complex>
{
	get int real;
	get int imaginary;
	public create(int real, int imaginary)
	{
		this:real = real;
		this:imaginary = imaginary;
	}
	public add(Complex other) => (Complex)
	{
		return Complex:create(real + other:real, imaginary + other:imaginary);
	}
	public subtract(Complex other) => (Complex)
	{
		return Complex:create(real - other:real, imaginary - other:imaginary);
	}
	public multiply(Complex other) => (Complex)
	{
		return Complex:create(real * other:real - imaginary * other:imaginary,
			real * other:imaginary + imaginary * other:real);    
	}
	public equal(Complex other) => (boolean)
	{
		return real == other:real and imaginary == other:imaginary;
	}
}

Thus, objects of type Complex could be added together as shown below.

Complex a = Complex:create(1, 3);
Complex b = Complex:create(-5, 2);
Complex c = a + b;

In addition to the standard arithmetic operators, there’s an interface for the bitwise operators &, |, ^, <<, >>, <<<, >>>, and ~, but they come as a bundle. It’s expected that they will only be useful for classes that have bitwise behavior similar to an integer, like BigInteger.

Having the CanIndex<V,K> interface overloads the index operator ([]) to read values from an index. Consider the following code that allows array-like indexing of an ArrayList.

var band = ArrayList<String>:create();
band.add("John");
band.add("Paul");
band.add("George");
band.add("Ringo");
String drummer = band[3];

There’s also a CanIndexStore<V,K> interface that allows the index operator ([]) to be overloaded so that it can store values into an index. Both interfaces can be implemented independently of each other, allowed classes that can load from an index, classes that can store to an index, and classes that can do both. Consider the following code that stores values into a HashMap using array-like indexing.

var clan = HashMap<String, String>:create();
clan["Russell Jones"] = "ODB";
clan["Clifford Smith"] = "Method Man";
clan["Dennis Coles"] = "Ghostface Killah";

All integral Java types are signed. Java added some indirect support for unsigned manipulations in Java 8, but they still don’t have unsigned primitives. We do! Each integral type has an unsigned version. Be warned: You shouldn’t be using these unless you really have a good reason. Shadow type-checking is pretty strict, and unsigned types are not exempt. If you want to store an int value into a uint or vice-versa, you’ll have to do a cast.

See the section on numeric types and literals for details about using unsigned types.

When C was invented, not many people were thinking about how to store characters from all over the world in computer memory. Strings in C are built on sequences of the single byte char type. Various implementations of C++ have various styles of wide-character support.

Java’s solution was simple and elegant: Use UTF-16. The char type is two bytes, and a String is a sequence of those. Unfortunately, that means that the memory cost of storing plain old ASCII text doubled when compared to C. And there is a hole in the elegance of their solution. UTF-16 sometimes needs two char values to represent some characters, usually from Asian languages.

Shadow’s solution goes a step further with UTF-8, a variable byte size scheme. If you’re using plain old ASCII, it only costs you a byte per character. Many characters can be expressed in two bytes, although some require three or even four bytes. How does that work in a String?

A String is a sequence of byte values. If you index into a location using brackets ([]) or by calling the index() method, you’ll get a byte value. That’s great if all you care about is ASCII.

However, we use the four-byte code (short for codepoint) type to represent arbitrary UTF-8 characters. A String iterator can cycle through a String, returning each code value contained within it.