Citrine (programming language)

Short description: Programming language

Citrine

Paradigm| Object-oriented, prototype-based
Designed by| Gabor de Mooij, Aavesh Jilani
Developer| Gabor de Mooij, Aavesh Jilani
First appeared| 2014
Stable release|

0.9.2 / 2020; 3 years ago (2020)

Typing discipline| dynamic
OS| Cross-platform (multi-platform)
License| BSD
Filename extensions| ctr
Website| citrine-lang.org
Major implementations

Influenced by
Smalltalk, Self

Citrine is a general-purpose programming language for Cross-platform (multi-platform) operating systems. It focuses on readability and maintainability. Readability is achieved by syntactic and conceptual minimalism. The language is heavily inspired by Smalltalk and Self but has some very distinctive features. Like Smalltalk, Citrine treats everything as an object and focuses on sending messages to these objects. However unlike Smalltalk, Citrine lacks the concept of a class. In this regard, Citrine is more like Self and JavaScript because it uses prototypes. The combination of Smalltalk like messages and prototypes is what makes Citrine unique.

As of the 0.7 version Citrine has focused on supporting native human languages instead of just English to help people reduce the number of bugs because of confusion and misunderstanding due to language barriers. As such Citrine 0.7 and higher feature a translator to translate between human languages.

## Contents

* 1 Syntax
* 2 Control flow
* 3 Pipelines
* 4 Prototypes
* 5 Unicode
* 6 Scoping
* 7 See also
* 8 References
* 9 External links

## Syntax

Citrine has a very limited syntax and it's very closely related to Smalltalk. Everything in Citrine is an object, there are 5 literals:

* `Nil`
* `True, False`
* `0,1,2,3`
* `'String'`
* `{ ...params.. ...block of code... }`

The code block literal uses a pipe symbol to separate the parameters from the logic '|', if there are no parameters, the backslash should be used instead of '\'.

Citrine only supports full-line comments, comments start with a '#'.

A Citrine program is basically a sequence of messages sent to objects. For instance, to determine whether 5 is an even number, the message 'even?' is sent to the number 5.

5 even?

This is called a unary message because it takes no arguments. A binary message is always a single UTF-8 character; this differs from Smalltalk, where there is a fixed set of binary messages. Here is an example:

6 + 7.

Here a binary message '+' is sent to number 6, the argument of this binary message is '7', this will result in a new number object '13'. Assigning the outcome of this operation to a variable uses the assignment operator: :=.

total := money + debt.

Also note that each line in a Citrine program ends with a dot, just like in Smalltalk. Besides unary and binary messages, Citrine offers keyword messages, which take arguments interspersed with the message itself just like Smalltalk and Objective-C.

☞ x := Number between: 1 and: 5.

The code snippet above will return a boolean object True.

## Control flow

Just like Smalltalk, control flow in Citrine is implemented by strategic use of messages. For instance, writing a conditional statement requires sending a block of code to a boolean.

(money > price) true: { ✎ write: 'Yes, you can afford this'. }.

Likewise, a for-loop is written as:

{ :step ✎ write: 'this is step:' + step. } × 10.

To break out of a loop in Citrine one has to send the message 'break' to a boolean, this allows a conditional break from a loop without having to factor out the break conditions:

{ :i
(i = 3) break.
✎ write: i.
} * 5.

## Pipelines

Unlike Smalltalk, Citrine has no semi-colon to send a message to the original receiver. Instead Citrine has a comma token ',' used to chain keyword messages, this allows writing Unix-like pipelines. The following code uses a pipeline-like syntax to replace all the 'o' characters with zeroes, the resulting string would be something like: '1010101...'.

onesAndZeroes := '1o1o1o1o1o1' split: 'o', map: mapUp, join: '0'.

## Prototypes

The biggest difference from Smalltalk is the use of prototypes. Citrine does not have a concept of a class, it only knows about objects. An object is created using the new message:

cat := Object new.

This object can be made to respond to messages by ordering the object to listen to events. This is kind of similar to adding methods in languages like Java:

cat on: 'meow' do: {
Pen write: 'meow!'.

As stated above, inheritance is based on prototypes. To derive an object from another object, the new message must be sent to the object to be extended:

☞ Animal := Object new.
Animal on: 'makeSound' do: {
✎ write: '?'.

☞ Cat := Animal new.
Cat on: 'makeSound' do: {
✎ write: 'meow!'.

☞ Tom := Cat new.
Tom makeSound.

## Unicode

Citrine uses UTF-8 unicode extensively, both objects and messages can consist of unicode symbols. All string length are calculated using UTF-8. Citrine distinguishes string length and size in bytes:

'text' length.

returns the length of the string in UTF-8 code points, while:

'text' bytes.

returns the number of bytes.

## Scoping

Citrine uses dynamic scoping instead of lexical scoping. Thus, there is no need for dependency injection or global variables, but it might be harder to reason about than lexical scope. This is similar in programming languages like Emacs Lisp and BASIC. In code blocks the var keyword needs to be used to declare a local variable.

The following demonstration makes the Mailer object available in the module:

Application := {
☞ mailer := Mailer new.
module run.

## See also

* Smalltalk programming language

## References

* demo in new programming languages community
* Citrine Review Jaxenter
* Announcement on Reddit
* InfoWorld interview
* Tiobe Index

## External links

* source code, Source code on GitHub

0.00

(0 votes)

Original source: https://en.wikipedia.org/wiki/Citrine (programming language). Read more

|

Retrieved from "https://handwiki.org/wiki/index.php?title=Citrine_(programming_language)&oldid=2650625"