Content deleted Content added
m linking |
m →top: replaced: primitively-defined → primitively defined |
||
| (20 intermediate revisions by 17 users not shown) | |||
Line 1:
{{Short description|None}}
{{primary sources|date=January 2017}}
Line 10 ⟶ 11:
| latest release version = 1.3.3
| latest release date = {{Start date and age|2017|08|21}}
| typing = [[
| scope =
| programming language =
Line 43 ⟶ 44:
}}
'''Ceylon'''
| url=http://ceylon-lang.org/blog/2013/09/22/ceylon-1/
| title=Ceylon 1.0 beta
Line 63 ⟶ 64:
| title=FAQ about language design: Goals
| access-date=2015-12-04}}</ref>
* A type system enforcing [[null safety]] and list element existence at compile time
* Regular syntax and semantics, avoiding special cases and primitively
* Support for generic programming and metaprogramming, with [[Reification (computer science)|reified]] [[Parametric polymorphism|generics]]
* Modularity built into the language, based on [[WildFly|JBoss modules]], interoperable with [[OSGi]]<ref>{{cite web
Line 82 ⟶ 83:
The name "Ceylon" is an oblique reference to Java, in that [[Java]] and [[Sri Lanka]], formerly known as Ceylon, are islands known for growth and export of [[coffee]] and [[tea]].
In August 2017, Ceylon was donated to the [[Eclipse Foundation]]. Development slowed down and finally stopped in 2020.<ref>{{cite web
|date=2020-05-25
|title= ceylon / ceylon
|publisher=GitHub, Inc.
|url=https://github.com/eclipse-archived/ceylon
|access-date=2024-01-22
|archive-url=https://web.archive.org/web/20231003075404/https://github.com/eclipse-archived/ceylon
|archive-date=2023-10-03
|url-status=live}}
</ref> In April 2023, [[Eclipse Foundation]] declared the termination of the transition.<ref>{{cite web
|date=2023-04-05
|title= Eclipse Ceylon™ Termination Review
|publisher=Eclipse Foundation
|url=https://projects.eclipse.org/projects/technology.ceylon/reviews/termination-review
|access-date=2023-04-23
|archive-url=https://web.archive.org/web/20230423134055/https://projects.eclipse.org/projects/technology.ceylon/reviews/termination-review
|archive-date=2023-04-23
|url-status=live}}</ref>
== Language features ==
Line 90 ⟶ 108:
One of the most novel aspects of Ceylon compared to Java is its [[type system]]. Ceylon foregoes Java's primitive types<ref>{{cite web|last1=King|first1=Gavin|title=Ceylon: Language Design FAQ|url=http://ceylon-lang.org/documentation/faq/language-design/}}</ref> and [[Object type|boxing]] in favor of a type system composed entirely of first-class objects. While this may cause boxing overhead in some situations, it makes the type system more uniform.
Ceylon allows for union and [[intersection type]]s, in a similar fashion to [[TypeScript]], [[Whiley (programming language)|Whiley]] and Flow, which in fact, took the idea from Ceylon.
Union types, written <code>A|B</code>, allow a variable to have more than one type. The following example shows a Ceylon function which may take either an [[Integer (computer science)|integer]] or a [[String (computer science)|string]]:
<
shared void integerOrString(Integer|String input) {
if (is Integer input) {
Line 102 ⟶ 120:
}
}
</syntaxhighlight>
Intersection types, written <code>A&B</code>, are the theoretical foundation of [[flow-sensitive typing]]:
<
shared void integerOrString(Integer|String input) {
Integer added = input + 6; // illegal; the + operator is not defined on Integer|String
Line 117 ⟶ 135:
}
}
</syntaxhighlight>
The condition <code>is Integer input</code> narrows the type of <code>input</code> to <code><Integer|String> & Integer</code>,
Line 125 ⟶ 143:
==== Null safety ====
Union and intersection types are used to provide [[null safety]].
The top type of the Ceylon type hierarchy is the class <code>Anything</code>,
which has two subclasses: <code>Object</code>, the superclass of all normal classes and all interfaces, and <code>Null</code>, with the only instance [[Null pointer|<code>null</code>]].
Line 137 ⟶ 155:
Intersection types can be used to get a non-optional type out of a possibly-optional type, such as a type parameter. For example, the signature of a function that removes <code>null</code> elements from a stream of values could be:
<
Iterable<Element&Object> removeNulls<Element>(Iterable<Element> stream);
</syntaxhighlight>
When <code>removeNulls</code> is called with a stream of <code>Integer|Null</code> elements, the result will be a stream of <code><Integer|Null> & Object</code> elements, which simplifies to <code>Integer</code>.
==== Functions ====
Similarly to many modern languages, Ceylon supports [[first class
<
// A top-level higher-order function using block syntax (not associated with any user-created classes)
String process(String text, String transformString(String toChange)) {
Line 161 ⟶ 179:
String reversed1 = process("one", reverse);
//
String reversed2 = process("one", (text) => text+text);
</syntaxhighlight>
==== Enumerated types ====
Similar to Java and many other languages, and with a similar mechanism as [[Algebraic data type|algebraic types]], Ceylon supports [[enumerated type]]s, otherwise known as enums. This is implemented in Ceylon with a pattern of limiting the instances of an abstract class at declaration to a limited set of objects (in this case, singleton instances). Another way to implement this pattern is with the new constructor feature in Ceylon 1.2 where the objects are implemented as different named constructor declarations.<ref>{{cite web|last=King|first=Gavin|title=The Ceylon Language: 4.5.8 Enumerated classes |url=http://ceylon-lang.org/documentation/1.2/spec/html/declarations.html#classeswithcases|access-date=6 December 2015}}</ref>
<
// Traditional syntax for enumerated type, in this case, limiting the instances to three objects(for this purpose: Singletons)
abstract class Vehicle(shared String name) of plane | train | automobile {}
Line 192 ⟶ 210:
//shared new boat extends named("boat") {}
}
</syntaxhighlight>
==== Type inference ====
Line 200 ⟶ 218:
The following two definition pairs are each equivalent:
<
Integer i = 3;
value i = 3;
Line 210 ⟶ 228:
return i1 + i2;
}
</syntaxhighlight>
However, to make single-pass type inference possible, type inference is only allowed for non-toplevel and unshared declarations.<ref>{{cite web
Line 220 ⟶ 238:
=== Entry point with names===
By default the starter (<code>ceylon run</code>) runs the shared run() function of a module:
<
/* The classic Hello World program */
shared void run() {
print("Hello, World!");
}
</syntaxhighlight>
but any other shared function without parameters can be used as main calling the program with the
<code>ceylon run --compile=force --run hello default</code>
| |||