Language features
Magik uses the # token to mark sections of code as comments:
# This is a comment.
Assignments
Magik uses the << operator to make assignments:
a << 1.234 b << b + a c << "foo" + "bar" # Concat strings
For clarity, this notation is read as "a becomes 1.234" or "b becomes b plus a". This terminology separates assignment from comparison.
Magik also supports a compressed variation of this operator that works in a similar way to those found in C:
b +<< a # Equivalent to b << b + a
To print a variable you can use the following command
a << "hello" write(a)
Symbols
As well as conventional data types such as integers, floats and strings Magik also implements symbols. Symbols are a special token data type that are used extensively throughout Magik to uniquely identify objects. They are represented by a colon followed by a string of characters. Symbols can be escaped using the vertical bar character. For example:
a << :hello # whenever :hello is encountered, it is the same instance b << :|hello world|
Dynamic typing
Magik variables are not typed as they are in say C# and can reference different objects at runtime. Everything in Magik is an object (there is no distinction between objects and primitive types such as integers):
a << 1.2 # a floating point number is assigned to variable 'a' a << "1.2" # later, a string is assigned to variable 'a'
- Objects
Objects are implemented in Magik using exemplars. Exemplars have similarities to classes in other programming languages such as Java, but with important differences. Magik supports multiple inheritance, and mixins (which implement functionality with no data). New instances are made by cloning an existing instance (which will typically be the exemplar but does not have to be).
New exemplars are created using the statement def_slotted_exemplar(), for example:
def_slotted_exemplar(:my_object, { {:slot_a, 34}, {:slot_b, "hello"} }, {:parent_object_a, :parent_object_b}) This code fragment will define a new exemplar called my_object that has two slots (or fields) called slot_a (pre-initialised to 34) and slot_b (pre-initialised to "hello") that inherits from two existing exemplars called parent_object_a and parent_object_b.
Comparison
Magik implements all usual logical operators (=, <, <=, >, >=, ~=/<>) for comparison, as well as a few unusual ones. The _is and _isnt operators are used for comparing specific instances of objects, or object references rather than values.
For example:
a << "hello" b << "hello" a = b # returns True (_true) because the values of a and b are equal a _is b # returns False (_false) because a is not the same instance as b a << "hello" b << a a = b # returns True (_true) because the values of a and b are equal a _is b # returns True (_true) because b was assigned the specific instance of the same object as a, rather than the value of a.
Methods
Methods are defined on exemplars using the statements _method and _endmethod:
_method my_object.my_method(a, b) _return a + b _endmethod
It is convention to supply two methods new() (to create a new instance) and init() (to initialise an instance).
# New method _method person.new(name, age) _return _clone.init(name, age) _endmethod # Initialise method. _private _method person.init(name, age) # Call the parent implementation. _super.init(name, age) # Initialise the slots. .name << name .age << age _return _self _endmethod
The _clone creates a physical copy of the person object. The _super statement allows objects to invoke an implementation of a method on the parent exemplar. Objects can reference themselves using the _self statement. An object's slots are accessed and assigned using a dot notation.
Methods that are not part of the public interface of the object can be marked private using the _private statement. Private methods can only be called by _self, _super and _clone.
Optional arguments can be declared using the _optional statement. Optional arguments that are not passed are assigned by Magik to the special object _unset (the equivalent of null). The _gather statement can be used to declare a list of optional arguments.
_method my_object.my_method(_gather values) _endmethod
Iteration
In Magik the _while, _for, _over, _loop and _endloop statements allow iteration.
_block _local s << 0 _local i << 0 _while i <= 100 _loop s +<< i i +<< 1 _endloop >> s _endblock
Here, the _while is combined with _loop and _endloop.
_method my_object.my_method(_gather values) total << 0.0 _for a _over values.elements() _loop total +<< a _endloop _return total _endmethod m << my_object.new() x << m.my_method(1.0, 2, 3.0, 4) # x = 10.0
Here values.elements() is an iterator which helps to iterate the values.
In Magik generator methods are called iterator methods. New iterator methods can be defined using the _iter and _loopbody statements:
_iter _method my_object.even_elements() _for a _over _self.elements() _loop _if a.even? _is _true _then _loopbody(a) _endif _endloop _endmethod
Procedures
Magik also supports functions called procedures. Procedures are also objects and are declared using the _proc and _endproc statements. Procedures are assigned to variables which may then be invoked:
my_procedure << _proc @my_procedure(a, b, c) _return a + b + c _endproc x << my_procedure(1, 2, 3) # x = 6
Regular expression
Magik supports // regular expression syntax:
_if /Hello\,\s(\w)+!/.matches?("Hello, Magik!") _then write("Got a match!") _endif and to capture groups in Regex:
/sw([0-9]+)-([0-9]+).*/.replace_all("sw65456-324sss", "$1") # "65456" /sw([0-9]+)-([0-9]+).*/.replace_all("sw65456-324sss", "$2") # "324" HTTP library
Magik supports making HTTP or HTTPS requests via http library, see below examples:
magikhttp << http.new() magikhttp.url("https://www.google.com").get() magikhttp.url("https://www.google.com").post({"User-agent", "Bot"}, "some data") Language quirks
Because Magik was originally developed in England, methods in the core smallworld libraries are spelled using British English. For example:
Use "initialise", not "initialize".
Collections
Like other programming language Magik too has collections. They include the following:
