Share your knowledge: March 2014

Friday, March 28, 2014

Ceylon: building typesafe webpages with the html module

	import ceylon.html { Html, html5, Head, Body, P, H2, Ul, Li }

	/**
	Remark: Don't forget to import the html module in your module !!

	import ceylon.html "1.0.0";


	Output of program:

	<!DOCTYPE html>

	<html>
	<head>
	<title>
	Hello Ceylon
	</title>
	</head>
	<body>
	<h2>
	Introduction
	</h2>
	<ul>
	<li>
	Basics
	</li>
	<li>
	Classes
	</li>
	</ul>
	</body>
	</html>
	**/
	void htmlDemo() {
	Html html = Html {
	doctype = html5;
	head = Head { title = "Hello Ceylon"; };
	body = Body {
	H2 { text = "Introduction";},
	Ul {
	Li {text = "Basics";},
	Li {text = "Classes";}
	}
	};
	};

	print(html);
	}

view raw gistfile1.ceylon hosted with ❤ by GitHub

Ceylon: dealing with files

As we saw earlier Ceylon is modularized. So the API to deal with files is not part of the core language. Check Modularity for how to specify a dependency on Ceylon file.

	import ceylon.file { ... }

	/**
	the parsePath function returns a Path. A path's resource either refers to an ExistingResource or Nil.
	An ExistingResource is one of File\|Directory\|Link.
	**/

	void readFile() {
	Path demoFilePath = parsePath("c:/tmp/demo.txt");
	if (is File file = demoFilePath.resource) {
	//below we define a resource expression. We don't need to take care of opening and
	//closing the resource ourselves.
	try (reader = file.Reader()) {
	//readLine returns a String?, null if there is no more line so we
	//conveniently print lines while the end of file has not been reached
	while (is String line = reader.readLine()) {
	print(line);
	}
	}
	}
	}

view raw gistfile1.ceylon hosted with ❤ by GitHub

	import ceylon.file { ... }

	/**
	In this little exercise we will write all words from a text to
	a newline starting with a line number to a file:

	0:I
	1:like
	2:programming
	**/
	void writeFile() {
	String text = "I like programming";
	Path filePath = parsePath("c:/tmp/words.txt");
	//now we need to make sure the file does not already exist
	if (is Nil resource = filePath.resource) {
	File file = resource.createFile();
	try (writer = file.Overwriter()) {
	for (index -> word in entries(text.split())) {
	writer.writeLine("``index``:``word``");
	}
	}
	}
	}

view raw gistfile1.ceylon hosted with ❤ by GitHub

	/**
	Let's say we want to move the following folder
	c:/tmp/map1 and its content
	to
	c:/tmp/movedmap
	**/
	void moveFolder() {
	Path sourcePath = parsePath("c:/tmp/map1");
	Path targetPath = sourcePath.siblingPath("movedmap");
	if (is Directory sourceDir = sourcePath.resource) {
	if (is Nil targetDir = targetPath.resource) {
	sourceDir.move(targetDir);
	}
	}
	}

view raw gistfile1.ceylon hosted with ❤ by GitHub

Ceylon: modularity

	What is modularity?

	*********************
	Source: Wikipedia
	*********************
	Modularity is the degree to which a system's components may be separated and recombined.

	In software design, modularity refers to a logical partitioning of the "software design"
	that allows complex software to be manageable for the purpose of implementation and maintenance.
	The logic of partitioning may be based on related functions, implementation considerations,
	data links, or other criteria.


	***************
	In practise:
	***************
	Let's say you have a project which has 2 immediate dependencies:

	- Dependency A version 2.1 (logging)
	- Dependency B version 1.4 (persistence)

	BUT library B in its turn also has a dependency on A but version 1.8. So the total dependencies become

	- Dependency A version 2.1 (logging)
	- Dependency B version 1.4 (persistence)
	- Dependency A version 1.8 (logging)


	Currently all dependencies are thrown in 1 big bag and the classloader picks 1 class from that bag.
	It might however pick the wrong version.

	So we need a way to enable modularity, where we are guaranteed the correct version of the class is used.

	For Java "Project Jigsaw" will eventually enable this kind of modularity.
	For Ceylon, Modularity is at the very core of the language, SDK and tooling.

view raw gistfile1.txt hosted with ❤ by GitHub

	/**
	In Ceylon, you create modules and each module specifies its own dependencies.
	Just like with a maven repository, modules can be shared. You can browse which Ceylon modules are available
	at http://modules.ceylon-lang.org/

	A nice thing is that you can even get autocompletion from within the IDE.

	If you start typing "import " and press ctrl-space you get all available modules.

	Below an example of what a module descriptor looks like.
	**/
	module pelssers.learningbyexample "1.0.0" {
	import ceylon.file "1.0.0";
	import ceylon.collection "1.0.0";
	}

view raw gistfile1.ceylon hosted with ❤ by GitHub

Tuesday, March 18, 2014

Ceylon: error handling the functional way

	/**
	Error handling (functional way)

	Whenever you call a method which might result in an exception,
	in Java you throw an exception which can be caught by the calling method.

	But in functional programming there is a tendency to not throw an exception but return it
	and make this fact explicit in the return type as well.

	In Scala they came up with the Try type which represents a computation that
	may result in a value of type A if it is succesful, or in some Throwable if
	the computation failed.

	In Ceylon there is no need for a Try type, as you can directly use a union type.
	**/

	shared class NegativeAgeException() extends Exception("Age can never be negative!") {}
	shared class Person(shared Integer age) {
	shared actual String string => "Person(``age``)";
	}

	shared object personBuilder extends Basic() {

	shared Person \| NegativeAgeException build(Integer age) {
	return age > 0 then Person(age) else NegativeAgeException();
	}
	}

	/**
	main prints

	pelssers.demo.NegativeAgeException "Age can never be negative!"
	**/
	void main() {
	Person\|NegativeAgeException person = personBuilder.build(-3);

	//now we first MUST narrow the union type in order to use it
	if (is Person person) {
	print("``person`` is valid");
	} else if (is NegativeAgeException person) {
	print(person);
	}
	}

view raw gistfile1.ceylon hosted with ❤ by GitHub

Thursday, March 13, 2014

Ceylon: creating testdata is a breeze

	/**
	In java it's really difficult to create complex objects for unit testing. There have been some attempts to
	workaround this difficulty like using
	- Object mothers --> factories to create objects (this becomes messy very quickly as well)
	- Test Data builders --> http://java.dzone.com/articles/creating-objects-java-unit-tes

	In Ceylon it becomes really easy to create testdata in an easy fashion as we will see.
	We just make use of named arguments to construct our objects.
	**/

	shared class Car(engine, radio, tires) {
	shared Engine engine;
	shared Radio radio;
	shared {Tire*} tires;
	shared actual String string =>
	"Car {
	engine=``engine``
	radio=``radio``
	tires=``tires``
	}";
	}

	shared class Engine(shared Float horsepower) {
	shared actual String string => "Engine(``horsepower``)";
	}
	shared class Radio(shared String type) {
	shared actual String string => "Radio(``type``)";
	}
	shared class Tire(shared String brand) {
	shared actual String string => "Tire(``brand``)";
	}

	/**
	Using the multiline string representation of Car we get a really nicely
	formatted output :)

	Car {
	engine=Engine(150.0)
	radio=Radio(FM)
	tires=[Tire(Pirelli), Tire(Pirelli), Tire(Pirelli), Tire(Pirelli)]
	}
	**/
	void demoCreatingTestData() {
	Car car = Car {
	engine = Engine(150.0);
	radio = Radio("FM");
	tires = {Tire("Pirelli"),Tire("Pirelli"),Tire("Pirelli"),Tire("Pirelli")};
	};
	print(car);
	}

view raw gistfile1.ceylon hosted with ❤ by GitHub

Monday, March 10, 2014

Ceylon: named arguments and declarative syntax for object creation

	class Movie(String title, Director director, {Actor+} actors) {
	shared actual String string => "Movie(title=``title``, Director=``director``, actors=``actors``)";
	}

	class Director(String name) {
	shared actual String string => "Director(``name``)";
	}

	class Actor(String name) {
	shared actual String string => "Actor(``name``)";
	}

	/**
	demo prints

	Movie(title=Avatar, Director=Director(James Cameron),
	actors=[Actor(Sam Worthington), Actor(Sigourney Weaver)])
	**/
	void demo() {
	Movie movie1 =
	Movie(
	"Avatar",
	Director("James Cameron"),
	{Actor("Sam Worthington"), Actor("Sigourney Weaver")}
	);


	//now we are going to construct a movie using declarative object instantiation
	//As you can see this looks like a DSL language to construct objects whereas
	//in fact you're just making good use of named arguments
	Movie movie2 = Movie {
	title = "Avatar";
	director = Director("James Cameron");
	actors = {Actor("Sam Worthington"), Actor("Sigourney Weaver")};
	};
	print(movie2);
	}

view raw gistfile1.ceylon hosted with ❤ by GitHub

Ceylon: overriding equals and hash

	/**
	Best practises for implementing Equals and Hash methods
	Source: http://www.artima.com/lejava/articles/equality.html
	------------------------------------------------------------
	Common pitfalls when overriding equals:

	- Defining equals with the wrong signature.
	- Changing equals without also changing hashCode.
	- Defining equals in terms of mutable fields.
	- Failing to define equals as an equivalence relation.



	The contract of the equals method in Object specifies that equals must
	implement an equivalence relation on non-null objects:

	It is reflexive:
	for any non-null value x, the expression x.equals(x) should return true.

	It is symmetric:
	for any non-null values x and y, x.equals(y) should return true if and only if y.equals(x) returns true.

	It is transitive:
	for any non-null values x, y, and z, if x.equals(y) returns true and y.equals(z) returns true,
	then x.equals(z) should return true.

	It is consistent:
	for any non-null values x and y, multiple invocations of x.equals(y) should consistently return true
	or consistently return false, provided no information used in equals comparisons on
	the objects is modified. For any non-null value x, x.equals(null) should return false.

	**/

	shared abstract class Colour(shared String name) of yellow \| orange \| green {
	shared actual Boolean equals(Object that) {
	if (is Colour that) {
	return that.canEqual(this) && name == that.name;
	}
	return false;
	}
	shared actual default Integer hash => name.hash;
	shared default Boolean canEqual(Object that) => that is Colour;
	}

	shared object yellow extends Colour("yellow") {}
	shared object orange extends Colour("orange") {}
	shared object green extends Colour("green") {}

	shared interface Coloured {
	shared formal Colour colour;
	}

	shared class Fruit(name) {
	shared String name;
	shared actual default Boolean equals(Object that) {
	if (is Fruit that) {
	return that.canEqual(this) && name == that.name;
	}
	return false;
	}
	shared actual default Integer hash => name.hash;
	shared default Boolean canEqual(Object that) => that is Fruit;
	}


	shared class ColouredFruit(String name, colour) extends Fruit(name) satisfies Coloured {
	shared actual Colour colour;
	shared actual Boolean equals(Object that) {
	if (is ColouredFruit that) {
	return that.canEqual(this) && name.equals(that.name) && colour.equals(that.colour);
	}
	return false;
	}
	shared actual default Integer hash => name.hash + colour.hash;
	shared actual default Boolean canEqual(Object that) => that is ColouredFruit;
	}

	/**
	comparefruits() prints
	banana1 equal to banana2 = false
	banana2 equal to banana1 = false
	**/
	void comparefruits() {
	Fruit banana1 = Fruit("banana");
	ColouredFruit banana2 = ColouredFruit("banana", yellow);
	print("banana1 equal to banana2 = ``banana1.equals(banana2)``");
	print("banana2 equal to banana1 = ``banana2.equals(banana1)``");
	}

view raw gistfile1.ceylon hosted with ❤ by GitHub

Friday, March 7, 2014

Ceylon: Range and Enumerable

	/**
	A quick look at the signature of Range reveals

	class Range<Element>
	extends Object() satisfies [Element+] & Cloneable<Range<Element>>
	given Element satisfies Ordinal<Element> & Comparable<Element>

	So in order to use a class in range notation we have to satisfy Ordinal & Comparable.
	Let's get started and come up with an example :)
	Oh yes... I used Enumerable which is a subtype of Ordinal.
	**/

	shared abstract class Priority(name, integerValue)
	of low \| middle \| high \| critical
	satisfies Enumerable<Priority> & Comparable<Priority> {
	shared String name;
	shared actual Integer integerValue;
	shared actual Comparison compare(Priority other) => integerValue <=> other.integerValue;
	shared actual String string => name;
	}

	//ATTENTION !! You have to use the arrow notation for defining successor
	//and predecessor, meaning it is lazy evaluated because otherwise
	//you will run into a cyclic initialization error.

	shared object low extends Priority("minor", 1) {
	shared actual Priority predecessor => critical;
	shared actual Priority successor => middle;
	}

	shared object middle extends Priority("middle", 2) {
	shared actual Priority predecessor => low;
	shared actual Priority successor => high;
	}

	shared object high extends Priority("high", 3) {
	shared actual Priority predecessor => middle;
	shared actual Priority successor => critical;
	}

	shared object critical extends Priority("critical", 4) {
	shared actual Priority predecessor => high;
	shared actual Priority successor => low;
	}

	/**
	This prints

	**************prios for range middle..critical
	middle
	high
	critical
	**************prios for range critical..middle
	critical
	high
	middle
	**************prios for range high..minor
	high
	middle
	minor
	**/
	void range_demo() {
	printPrios(middle..critical);
	printPrios(critical..middle);
	printPrios(high..low);
	}

	void printPrios(Range<Priority> prios) {
	print("**************prios for range ``prios``");
	for (prio in prios) {
	print(prio);
	}
	}

view raw gistfile1.ceylon hosted with ❤ by GitHub

Wednesday, March 5, 2014

Ceylon: Comparable interface and Comparison Class

	/**
	You can use the comparison operators
	<
	<=
	>
	>=
	for all Classes satisfying the Comparable interface.

	But Ceylon provides a nifty fourth operator, <=> which is the compare operator.
	This results in one of the singleton instances (equal, smaller or larger) of the class Comparison.

	**/

	void comparison_demo() {
	Boolean isFiveLargerThan2 = 5 > 2;
	print("isFiveLargerThan2 is ``isFiveLargerThan2``");
	Integer age = 37;

	switch(age <=> 50)
	case (smaller) { print("age is smaller than 50");}
	case (equal) {print("age is equal to 50");}
	case (larger) {print("age is larger than 50");}

	//just to double check !!
	Comparison comparison = age <=> 20; //compiles fine :)


	}

view raw gistfile1.ceylon hosted with ❤ by GitHub

Ceylon: Sequences and Iterables


	Boolean isOdd(Integer number) => number % 2 != 0;

	/**
	sequence_demo prints

	numbers=1..10
	oddNumbers={ 1, 3, 5, 7, 9 }
	doubledNumbers={ 2, 4, 6, 8, 10, 12, 14, 16, 18, 20 }
	sumOfNumbers=55

	**/
	void sequence_demo() {
	Integer[] numbers = 1..10; //here we use the range shortcut notation
	print("numbers=``numbers``");
	Iterable<Integer> oddNumbers = numbers.filter(isOdd);
	print("oddNumbers=``oddNumbers``");
	Iterable<Integer> doubledNumbers = numbers.map((Integer number) => number * 2);
	print("doubledNumbers=``doubledNumbers``");
	Integer sumOfNumbers = numbers.fold(0, (Integer partial, Integer elem) => partial + elem);
	print("sumOfNumbers=``sumOfNumbers``");
	}

view raw gistfile1.ceylon hosted with ❤ by GitHub

	/**
	Sequences are per definition nonempty and immutable.

	Normally you would start out with the subtype Empty of Sequential (singleton instance empty)
	But looking at the API of Empty we don't see any append or add methods
	So how do we gradually build a sequence?

	There are 2 classes which come to the rescue in this case
	- SequenceBuilder (which has a no-arg constructor) => starts from empty.
	- SequenceAppender (which takes a sequence as constructor parameter) => starts from non empty sequence

	One should however carefully think about whether using a sequencebuilder or sequenceappender is
	really necessary. Most of the times you start out from input which you just have to filter or map.
	**/

	class Manager(shared String name) {}

	void buildSequenceDemo() {
	String[] names = ["John", "Peter", "Sammy"];
	Manager[] managers1 = createManagersFromNames(names);

	//however, more idiomatic would have been
	{Manager*} managers2 = names.map((String name) => Manager(name));

	//we can also use a comprehension
	{Manager*} managers3 = {for (name in names) Manager(name)};

	//or if you really need a sequence instead of an iterable
	Manager[] managers4 = names.map((String name) => Manager(name)).sequence;

	//we can also use a comprehension
	Manager[] managers5 = [for (name in names) Manager(name)];
	}

	Manager[] createManagersFromNames(String[] names) {
	SequenceBuilder<Manager> sb = SequenceBuilder<Manager>();
	for (name in names) {
	sb.append(Manager(name));
	}
	return sb.sequence;
	}


	void appendDemo() {
	/**
	Attention: code below does not work because you have to be explicit about
	names1 being a NON EMPTY sequence
	**/
	//String[] names1 = ["John", "Peter", "Sammy"];

	[String+] names1 = ["John", "Peter", "Sammy"];
	String name = "Ronald";

	String[] combined = SequenceAppender(names1).append(name).sequence;
	}

view raw gistfile1.ceylon hosted with ❤ by GitHub

Ceylon: Singletons

	/**
	A singleton is the one and only possible instance of a Class. In languages like Java you have to use
	all kinds of crazy patterns to accomplish this.

	See http://en.wikipedia.org/wiki/Singleton_pattern

	Not so in Ceylon however :) You just need to use an algebraic type with a single subtype (object)
	**/


	shared abstract class Earth() of earth {}
	shared object earth extends Earth(){}

	//WON'T COMPILE ==> not a subtype of any case of enumerated supertype: BabyEarth is a subtype of Earth
	//class BabyEarth() extends Earth() {}

	//WON'T COMPILE ==> not a subtype of any case of enumerated supertype: BabyEarth is a subtype of Earth
	//shared object babyEarth extends Earth() {}

view raw gistfile1.ceylon hosted with ❤ by GitHub

Ceylon: Higher order functions

	class Coordinate(x, y) {
	shared Integer x;
	shared Integer y;
	shared actual String string => "Coordinate(``x``,``y``)";
	}

	class Car(shared String name, position) {
	shared variable Coordinate position;
	shared void moveUp() => position = Coordinate(position.x, position.y + 1);
	shared actual String string => "``name`` located at ``position``";
	}


	void repeat(Integer times, Anything action()) {
	for (i in 1..times) {
	action();
	}
	}


	/**
	this demo prints

	car1 located at Coordinate(5,20)
	car1 located at Coordinate(5,30)
	car2 located at Coordinate(0,40)
	car2 located at Coordinate(0,50)
	**/
	void higherorder_demo() {
	Car car1 = Car("car1",Coordinate(5,20));
	print(car1);
	//now we can move our car 10 times up like this
	for (i in 1..10) {
	car1.moveUp();
	}
	print(car1);

	//or we just call the higher order function repeat
	Car car2 = Car("car2",Coordinate(0,40));
	print(car2);
	repeat(10, car2.moveUp);
	print(car2);
	}

view raw gistfile1.ceylon hosted with ❤ by GitHub

Ceylon: Algebraic datatypes

	shared interface DecisionTree<out Element, in Argument> of
	Branch<Element,Argument> \| Leave<Element,Argument> {
	shared formal Element evaluate(Argument arg);
	}

	shared interface Branch<out Element,in Argument> satisfies DecisionTree<Element,Argument> {
	//the predicate could be represented like this
	//shared formal Callable<Boolean, [Argument]> predicate;

	//but below we see the syntactic sugar declaration
	shared formal Boolean(Argument) predicate;

	shared formal DecisionTree<Element, Argument> left;
	shared formal DecisionTree<Element, Argument> right;
	shared actual Element evaluate(Argument arg) {
	if (predicate(arg)) {
	return left.evaluate(arg);
	} else {
	return right.evaluate(arg);
	}
	}
	}

	shared interface Leave<out Element, in Argument> satisfies DecisionTree<Element,Argument> {
	shared formal Element element;
	}


	class Purchase(isMember, hasCoupon) {
	shared Boolean isMember;
	shared Boolean hasCoupon;
	}


	class PurchaseBranch(left, right, predicate) satisfies Branch<Float, Purchase> {
	shared actual DecisionTree<Float,Purchase> left;
	shared actual Boolean(Purchase) predicate;
	shared actual DecisionTree<Float,Purchase> right;
	}

	class PurchaseLeave(element) satisfies Leave<Float, Purchase> {
	shared actual Float element;
	shared actual Float evaluate(Purchase arg) => element;
	}

	Boolean isMember(Purchase purchase) => purchase.isMember;
	Boolean hasCoupon(Purchase purchase) => purchase.hasCoupon;


	/**
	isMember
	\|
	_____________________________
	\| \|
	true false
	\| \|
	hasCoupon hasCoupon
	\| \|
	______________ ________________
	\| \| \| \|
	true false true false
	\| \| \| \|
	8 10 12 16

	running our program prints

	8.0
	10.0
	12.0
	16.0
	**/

	void algebraic_demo() {

	PurchaseBranch root = PurchaseBranch(
	PurchaseBranch(
	PurchaseLeave(8.0),
	PurchaseLeave(10.0),
	hasCoupon),
	PurchaseBranch(
	PurchaseLeave(12.0),
	PurchaseLeave(16.0),
	hasCoupon),
	isMember
	);

	print(root.evaluate(Purchase(true, true)));
	print(root.evaluate(Purchase(true, false)));
	print(root.evaluate(Purchase(false, true)));
	print(root.evaluate(Purchase(false, false)));
	}

view raw gistfile1.ceylon hosted with ❤ by GitHub

Ceylon: Tuples

	/**
	First of all, WHAT is a tuple?
	In Ceylon it's represented as a typed linked list with a not so easy signature
	as we will see later on.

	But let's first get the picture here. Why are tuples useful. Well, sometimes you want to return 2
	or more objects from a method. Now you NEED to write a wrapper class for this whereas with these
	generic Tuple classes, you can just construct them like any ordinary object. You only need
	to provide the correct type parameters.

	In Java and Scala Tuples are modelled a bit differently. A tuple with 2 elements could look like

	public class Tuple2<A, B> {
	private A first;
	private B second;

	public Tuple2(final A first, final B second) {
	this.first = first;
	this.second = second;
	}

	public A getFirst() {
	return first;
	}

	public B getSecond() {
	return second;
	}
	}

	Usage of such a tuple would be
	Tuple2<String, Integer> nameAndAge = new Tuple2<String, Integer>("Robby", 37);
	**/


	/**
	The tuples demo prints

	Robby
	Robby
	37
	37
	<null>
	**/
	void tuples_demo() {
	//Below we use the syntactic sugar syntax to create a tuple (Strongly recommended).
	[String, Integer] tuple1 = ["Robby", 37];

	/**
	Below we use the fully qualified type declaration of a tuple like above
	class Tuple<out Element, out First, out Rest=[]>

	So you first specify the Union type of the tuple => "String \| Integer"
	Next you specify the type of the First element => "String"
	Finally you recursively specify the same for the remainder (rest) => Tuple<Integer, Integer>
	**/
	Tuple<String\| Integer, String, Tuple<Integer,Integer>> tuple2 = ["Davy", 37];

	print(tuple1.first);
	print(tuple1.get(0));//should be the same as first
	print(tuple1.last);
	print(tuple1.get(1)); //should be the same as last
	print(tuple1.get(4)); //should print null
	}

view raw gistfile1.ceylon hosted with ❤ by GitHub

Ceylon: Interfaces and mixin inheritance

	class Coordinate(x, y) {
	shared Integer x;
	shared Integer y;
	shared actual String string => "Coordinate(``x``,``y``)";
	}

	/**
	As you can see interfaces in Ceylon can provide concrete implementation of
	methods, unlike java but comparable to Scala traits.
	**/
	interface Movable {
	shared formal variable Coordinate position;
	shared Coordinate moveUp() => position = Coordinate(position.x, position.y + 1);
	shared Coordinate moveDown() => position = Coordinate(position.x, position.y - 1);
	shared Coordinate moveLeft() => position = Coordinate(position.x - 1, position.y);
	shared Coordinate moveRight() => position = Coordinate(position.x + 1, position.y);
	}

	/**
	Here we define that our class MovableObject satisfies the interface Movable
	We have to provide an actual position and get all the move methods for free
	**/
	class MovableObject(position) satisfies Movable {
	shared actual variable Coordinate position;
	shared actual String string => "Object located at ``position``";
	}

	/**
	You can also provide a position when it's not passed as constructor parameter
	**/
	class MovableObject2(Integer x, Integer y) satisfies Movable {
	shared actual variable Coordinate position = Coordinate(x,y);
	shared actual String string => "Object located at ``position``";
	}


	/**
	This demo prints the following to the console

	Object located at Coordinate(5,10)
	Object located at Coordinate(5,11)
	Object located at Coordinate(4,11)
	**/
	void interface_demo() {
	MovableObject movable = MovableObject(Coordinate(5,10));
	print(movable);
	movable.moveUp();
	print(movable);
	movable.moveLeft();
	print(movable);
	}

view raw gistfile1.ceylon hosted with ❤ by GitHub

Tuesday, March 4, 2014

Ceylon: Optional types

	/**
	In case you haven't heard of optional types you might
	want to take your profession more seriously :)

	Yes, i'm referring to constructs like Scala's algebraic type called Option
	which is either a Some(T value) or a None

	Ceylon does not use a wrapper class but instead makes use of 2 new cool
	features which are baked into the language "Union and Intersection Types"
	together with type narrowing.

	So if you want to express that a value can be either of the declared type or
	null, you use the syntactic sugar notation (appending a question mark)

	In order to be able to call methods on an union type, you first have to narrow it down
	to a specific type. In this case we do this by testing for existence.

	**/

	class Person(fName, middleName, lName) {
	shared String fName;
	shared String? middleName; //optional
	shared String lName;


	shared actual String string {
	//below we narrow the type to String
	if (exists middleName) {
	return "(Person(``fName`` ``middleName`` ``lName``))";
	}
	return "(Person(``fName`` ``lName``))";
	}
	}

	/**
	We can however use the else construct to provide a default value if the optional type
	is indeed null. This saves a few lines of code and might be even clearer.
	**/
	class Person2(fName, middleName, lName) {
	shared String fName;
	shared String? middleName; //optional
	shared String lName;

	shared actual String string => "(Person(``fName`` ``middleName else ""`` ``lName``))";
	}

view raw gistfile1.ceylon hosted with ❤ by GitHub

	/**
	This demo prints

	5
	<null>
	**/

	void optional_demo() {
	//Below we use syntactic sugar notation for optional type which basically is
	//the union of types Integer and Null
	Integer? optional1 = getNumber("robby");
	//Below we use the fully qualified union type
	Integer \| Null optional2 = getNumber("john");
	print(optional1);
	print(optional2);
	}

	Integer? getNumber(String name) {
	return name.startsWith("r") then 5; //else null is implicit
	}

view raw gistfile1.ceylon hosted with ❤ by GitHub

Ceylon: Introduction to classes

	class ImmutablePerson1(firstName, lastName) {
	shared String firstName;
	shared String lastName;
	//below we override the super method Object.string which has a default implementation
	shared actual String string => "Person(``firstName`` ``lastName``)";
	}

	/**
	this is shortcut syntax but this is not the preferred way when you have more than
	2 class parameters (constructor parameters)
	**/
	class ImmutablePerson2(shared String firstName, shared String lastName) {
	}

	/**
	We can mutate firstName and lastName of instances of MutablePerson
	**/
	class MutablePerson(firstName, lastName) {
	shared variable String firstName;
	shared variable String lastName;
	shared actual String string => "Person(``firstName`` ``lastName``)";
	}

	/**
	We can even give default values to class parameters
	**/
	class DefaultPerson(firstName, shared String lastName="Pelssers") {
	shared String firstName;
	shared actual String string => "Person(``firstName`` ``lastName``)";
	}


	/**
	The main method prints

	*******************
	Person(Robby Pelssers)
	Robby
	*******************
	com.pelssers.demo.ImmutablePerson2@4400dfe4
	Davy
	*******************
	Person(Lindsey Pelssers)
	Lindsey
	*******************
	Person(Valerie Pelssers)
	Valerie
	*******************
	Person(Jef Pelssers)
	Jef
	*******************

	**/
	void main() {
	print("*******************");
	ImmutablePerson1 person1 = ImmutablePerson1("Robby", "Pelssers");
	print(person1);
	//person.firstName = "Davy"; WON'T COMPILE
	print(person1.firstName);
	print("*******************");

	ImmutablePerson2 person2 = ImmutablePerson2("Davy", "Pelssers");
	print(person2);
	print(person2.firstName);
	print("*******************");

	MutablePerson person3 = MutablePerson("Lindsey", "Pelssers");
	print(person3);
	print(person3.firstName);
	print("*******************");

	person3.firstName = "Valerie";
	print(person3);
	print(person3.firstName);
	print("*******************");

	DefaultPerson person4 = DefaultPerson("Jef");
	print(person4);
	print(person4.firstName);
	print("*******************");

	}

view raw gistfile1.ceylon hosted with ❤ by GitHub

	/**
	Below an example of how to extend other classes.
	Mammal has a default implementation for eating.
	Lion does not override eat() whereas
	Squirrel provides it's own implementation.
	**/

	class Mammal(shared String name="Mammal") {
	shared default void eat() {
	print("``name`` eating food.");
	}
	}

	class Lion() extends Mammal("Lion") {
	}

	class Squirrel() extends Mammal("Squirrel") {
	//here we override the default implementation
	shared actual void eat() {
	print("``name`` eating nuts.");
	}
	}

	class Cat() extends Mammal("Cat") {
	//shortcut notation to refine (override) a default implementation
	eat() => print("``name`` eating mouse.");
	}

	/**
	the demo prints the following to the console:

	Some mammal eating food.
	Lion eating food.
	Squirrel eating nuts.
	Cat eating mouse.
	**/
	void inheritance_demo() {
	Mammal mammal = Mammal("Some mammal");
	mammal.eat();
	Lion lion = Lion();
	lion.eat();
	Squirrel squirrel = Squirrel();
	squirrel.eat();
	Cat cat = Cat();
	cat.eat();
	}

view raw gistfile1.ceylon hosted with ❤ by GitHub

	abstract class Shape(name) {
	shared String name;
	shared formal Float circumference();
	shared formal Float area();
	shared actual String string => "``name`` with circumference=``circumference()``
	and area=``area()``".normalized;
	}

	class Rectangle(Float width, Float length) extends Shape("Rectangle") {
	circumference() => 2 * width + 2 * length;
	area() => width * length;
	}

	/**
	Running this program prints :

	Rectangle with circumference=70.0 and area=300.0
	**/
	void abstractclass_demo() {
	Rectangle rect = Rectangle(15.0, 20.0);
	print(rect);
	}

view raw gistfile1.ceylon hosted with ❤ by GitHub