ZenCode specification - Revision history

Aizistral: 11 revisions imported

2025-08-21T00:17:37Z

11 revisions imported

Stan at 17:42, 10 January 2015

2015-01-10T17:42:15Z

Stan at 17:30, 10 January 2015

2015-01-10T17:30:08Z

Stan at 16:31, 1 January 2015

2015-01-01T16:31:19Z

Stan at 16:28, 1 January 2015

2015-01-01T16:28:16Z

Stan at 16:27, 1 January 2015

2015-01-01T16:27:04Z

Stan at 16:09, 1 January 2015

2015-01-01T16:09:23Z

Stan at 15:11, 11 November 2014

2014-11-11T15:11:41Z

Stan at 15:11, 11 November 2014

2014-11-11T15:11:22Z

Stan at 15:10, 11 November 2014

2014-11-11T15:10:50Z

@@ Line 130: / Line 130: @@
   doStrings(["Hello", "world"]);
-Arrays can be passed to functions if the array base type is different. However, the array will be read-only, and the conversion will be performed only when needed. This means that conversion errors will come up only when the values are actually being accessed:
+Arrays can be passed to functions if the array base type is different. When such conversion is made, the converted array will always reflect the values in the original array: if the original is modified, the converted array will return the new values. If both base types can be converted to each other, the resulting array will be read-write. If not, the array will be read-only. Conversion between the array values is performed only when needed. This means that conversion errors will come up only when the values are actually being accessed:
   function printInts(values as int[])
@@ Line 143: / Line 143: @@
 The code above will print 1 and then crash, complaining that "Hello" is not an int value.
 This kind of behavior makes it possible to write a script quickly without ever having to bother about types whereas more complex applications, APIs and performance-critical code can use a static type system.
 = Statements =

@@ Line 50: / Line 50: @@
 ZenCode knows the following types:
-* All signed types as available: int java: byte, short, int, long
+* All signed types as available in java: byte, short, int, long
 * Unsigned variants of these type: ubyte, ushort, uint, ulong
 * Two floating-point types: float and double
@@ Line 61: / Line 61: @@
 * The special type void, indicating "no value"
-Classes and interfaces can contain generic parameters.
+Classes and interfaces can have generic type parameters.
 == Primitive types ==
@@ Line 77: / Line 77: @@
 * float: contains a single-precision floating-point value
 * double: contains a double-precision floating-point value
 * string: contains a string value (supports any unicode character)
 * void: means the same as "no value", cannot contain any value but used to indicate that a method doesn't return a value
@@ Line 92: / Line 93: @@
 - int[][] defines a two-dimensional array of integers. Each element in the outer array can be of different length, for example [[1, 2], [3, 4, 5]] is a correct value. Each element of the outer array is a reference to a smaller array.
-- int[,] defines a rectangular array. For example, [[1, 2, 3], [4, 5, 6]] would be a valid rectangular array but [[1, 2], [3, 4, 5]] isn't. There is only one array.
+- int[,] defines a rectangular array. For example, [[1, 2, 3], [4, 5, 6]] would be a valid rectangular array but [[1, 2], [3, 4, 5]] isn't. Internally, there is only one array.
 == Associative Arrays ==
 Being a very common structure, the ability to define dictionaries mapping values of one type to values of another type is a first-class language feature in ZenCode. They are called associative arrays and can be created with the {} notation.

@@ Line 41: / Line 41: @@
 [[File:grammar_script.png]]
 [[File:grammar_importedscript.png]]
 [[File:grammar_scriptelement.png]]

@@ Line 40: / Line 40: @@
   include "otherscript.zsi";
-[[File:grammar-script.png]]
+[[File:grammar_script.png]]
-[[File:grammar-importedscript.png]]
+[[File:grammar_importedscript.png]]
-[[File:grammar-scriptelement.png]]
+[[File:grammar_scriptelement.png]]
 = Types =

← Older revision		Revision as of 16:27, 1 January 2015
Line 39:		Line 39:

	include "otherscript.zsi";		include "otherscript.zsi";
		+
		+	[[File:grammar-script.png]]
		+	[[File:grammar-importedscript.png]]
		+	[[File:grammar-scriptelement.png]]

	= Types =		= Types =

← Older revision	Revision as of 00:17, 21 August 2025
(No difference)

@@ Line 3: / Line 3: @@
 = Introduction =
-The purpose of ZenCode is to make it possible for non-programmers to use a simple scripting language while allowing more experienced programmers to take advantage of all the speed and features offered by modern object-oriented languages. Currently, ZenCode compiles at runtime to java bytecode, but in future, other target platforms should be supported.
+The purpose of ZenCode is to make it possible for non-programmers (or programmers with little experience) to use a simple scripting language while allowing more experienced programmers to take advantage of all the speed and features offered by modern object-oriented languages. Currently, ZenCode compiles at runtime to java bytecode, but in future, other target platforms should be supported.
-The idea of ZenCode is that it can be used by a wide range of people. While experienced programmers can easily understand every detail that goes on under the hood, less experienced programmers and non-programmers could simply follow the tutorials and magically "have everything work" without having to bother about the details. For instance, ZenCode can be written with or without specifying data types. When used without types, the scripting engine can infer the types in most cases and use runtime-typed values in cases where it couldn't. It wouldn't be optimal in terms of speed, but it would work without having to teach the non-programmer all the ugly details about everything in the language.
+The idea of ZenCode is that it can be used by a wide range of people. While experienced programmers can easily understand every detail that goes on under the hood, less experienced programmers and non-programmers could simply follow the tutorials and magically "have everything work" without having to bother about the details. For instance, ZenCode can be written with or without specifying data types. When used without types, the scripting engine can infer the types in most cases and use runtime-typed values in cases where it couldn't. It wouldn't be optimal in terms of speed, but it would work without having to teach the non-programmer all the details about everything in the language.
-Meanwhile, more advanced programmers can specify types for those places where it can't be inferred, know everything that goes on under the hood, and write code that's both fast and clean. They would be able to write their advanced logic and make it available in the form of easily used APIs for less experienced users. This is particularly interesting in the modding world, where there is a mix of users with different skill levels. Making a Minecraft mod requires knowledge of both Java and Forge, which can be hard to learn for a non-programmer. However, many people would like to make simple modification to the game - modifications that are difficult to provide with a graphical user interface. A scripting language would be needed, but shouldn't need a user to know what classes and interfaces, be aware of the difference between a float and double or about the language's casting rules.
+Meanwhile, more advanced programmers can specify types for those places where it can't be inferred, know everything that goes on under the hood, and write code that's both fast and clean. They would be able to write their advanced logic and make it available in the form of easily used APIs for less experienced users. This is particularly interesting in the modding world, where there is a mix of users with different skill levels. Making a Minecraft mod requires knowledge of both Java and Forge, which can be hard to learn for a non-programmer. However, many people would like to make simple modifications to the game - modifications that are difficult to provide with a graphical user interface. A scripting language would be needed, but shouldn't need a user to know what classes and interfaces, be aware of the difference between a float and double or about the language's casting rules.
 = Types =

@@ Line 30: / Line 30: @@
 The following primitive types are available:
-- byte: signed integer value, can contain values from -128 to 127
+* byte: signed integer value, can contain values from -128 to 127
-- short: signed integer value, can contain values from -32768 to 32767
+* short: signed integer value, can contain values from -32768 to 32767
-- int: signed integer value, can contain values from –2147483648 to 2147483647
+* int: signed integer value, can contain values from –2147483648 to 2147483647
-- long: signed integer value, can contain values from -9223372036854775808 to 9223372036854775807
+* long: signed integer value, can contain values from -9223372036854775808 to 9223372036854775807
-- ubyte: unsigned integer value, can contain values from 0 to 255
+* ubyte: unsigned integer value, can contain values from 0 to 255
-- ushort: unsigned integer value, can contain values from 0 to 65535
+* ushort: unsigned integer value, can contain values from 0 to 65535
-- uint: unsigned integer value, can contain values from 0 to 4294967295
+* uint: unsigned integer value, can contain values from 0 to 4294967295
-- ulong: unsigned integer value, can contain values from 0 to 18446744073709551615
+* ulong: unsigned integer value, can contain values from 0 to 18446744073709551615
-- float: contains a single-precision floating-point value
+* float: contains a single-precision floating-point value
-- double: contains a double-precision floating-point value
+* double: contains a double-precision floating-point value
-- string: contains a string value (supports any unicode character)
+* string: contains a string value (supports any unicode character)
-- void: means the same as "no value", cannot contain any value but used to indicate that a method doesn't return a value
+* void: means the same as "no value", cannot contain any value but used to indicate that a method doesn't return a value
 == Arrays ==

@@ Line 13: / Line 13: @@
 ZenCode knows the following types:
- All signed types as available int java: byte, short, int, long
+* All signed types as available: int java: byte, short, int, long
-- Unsigned variants of these type: ubyte, ushort, uint, ulong
+* Unsigned variants of these type: ubyte, ushort, uint, ulong
-- Two floating-point types: float and double
+* Two floating-point types: float and double
-- The string type: string
+* The string type: string
-- Arrays; <type>[]
+* Arrays; <type>[]
-- Associative arrays (dictionaries, maps): <valuetype>[<keytype>]
+* Associative arrays (dictionaries, maps): <valuetype>[<keytype>]
-- Classes: can contain fields, methods and operators, can extend a superclass, and implement any number of interfaces
+* Classes: can contain fields, methods and operators, can extend a superclass, and implement any number of interfaces
-- Interfaces: can contain interface methods and static methods, implement other interfaces and provide default implementations for some of its methods
+* Interfaces: can contain interface methods and static methods, implement other interfaces and provide default implementations for some of its methods
-- Structs: value types grouping a number of fields - can contain methods but can't extend classes or implement interfaces
+* Structs: value types grouping a number of fields - can contain methods but can't extend classes or implement interfaces
-- The special type void, indicating "no value"
+* The special type void, indicating "no value"
 Classes and interfaces can contain generic parameters.