AnteScript

• Etymology...

• In JavaScript, the operator typically stands in between operands, for example: 52 + 20
• In PostScript, the operator typically stands on the right of the operands, for example: 52 20 add
• In AnteScript, the operator typically stands on the left of the operands, for example: add_ (52) (20)

• Syntax...

• In Object Oriented Programming, the method typically stands on the right of the object, for example: circle.surface()
• In Functional Programming, the function stands on the left of the data argument, for example: surface(circle)
• In AnteScript, the application stands on the left of the implementation argument, for example: surface_(circle)
• The AnteScript syntax is close to the Functional Programming syntax
• In AnteScript, applications may be concatenated, for example to compute the surface of the base of a cylinder: surface_(base_)(cylinder)
• In AnteScript, for syntax consistency, the left most application may also be surounded by parentheses, for example: (surface_)(base_)(cylinder)

• Concepts...

• Application...

• In AnteScript, the concept of application corresponds to the concept of function in Functional Programming
• An application is just a name (unlike a function declaration or definition in Functional Programming)
• An application is typically distinguished from other AnteScript concept by a naming convention (an underscore suffix): surface_
• A style preference consists in surounding an application by parentheses, for example: (surface_)(circle)
• Surounding an application by parentheses is not required (if it is the left most), for example: surface_(circle)
• Two or more levels of applications may be concatenated, to represent for example, the "surface" method of the "shape" interface: (surface_)(shape_)
• Several levels of applications may represent a namespace hierarchy as supported by popular programming languages
• Applications representing a namespace hierarchy are specified in reverse order, for example, the System.Collections.IList namespace hierarchy: (list_)(collections_)(system_)
• Unlike popular programming languages, partial namespace path are first-class citizens, for example, in the System.Collections.IList namespace hierarchy: (list_)(collections_)
• Application concatenation is associtive (but not commutative): ((list_)(collections_))(system_) === (list_)((collections_)(system_))

• Declaration...

• In AnteScript, the concept of declaration corresponds to both concepts of class and class consturctor in Object Oriented Programming
• A declaration specifies both the specification and the implementation
• The specification and implementation of a declaration is checked for consistency
• Applying values to a declaration (like calling a class constructor with value arguments) returns a definition
• Declaration can model Algebraic Data Types supported by popular Functional Programmming languages
• A declaration with two (or more) definition values models a product Algebraic Data Type
• A declaration with one definition value that can be defined from two (or mor) different declarations models a sum Algebraic Data Type
• A declaration is the function part in the separation of data and functions in Functional Programming
• A declaration may specify an optional delegation to handle applications that are missing in the implementation (the consistency check between the specification and implementation is looser when a delegation is specified)

• Specification...

• In AnteScript, the concept of specification corresponds to the concept of interface or abstract class in Object Oriented Programming
• A specification lists the supported applications
• A specification lists the supported concatenations of applications
• A specification may be recursive (in case of concatenation of applications)
• A specification may implement invariant applications and invariant concatenations of applications
• An invariant does not depend on the definition values
• A declaration specifies a specification
• A declaration specifying an implementation for an application not listed in the specification results in an error
• A declaration not specifying an implementation for an application listed in the specification results in an error
• A declaration specifying an implementation for an invariant application in the specification results in an error

• Implementation...

• An implementation specifies the code to implement supported applications (like a class definition in Object Oriented Programming)
• An implementation specifies the code to implement supported concatenations of applications (like a private class definition inside a class definition in Object Oriented Programming)
• An implementation may be recursive (in case of concatenation of applications)

• Definition...

• In AnteScript, the concept of definition corresponds to the concept of class instance in Object Oriented Programming
• A definition is defined by applying values to a declaration
• A supported application (or a supported concatenation of applications) may be applied to a definition
• Applying an unsupported application (or a unsupported concatenation of applications) to a definition results in an error
• A definition is the data part in the separation of data and functions in Functional Programming
• A definition encapsulates the values like private data class members in Object Oriented Programming

• Extension...

• In AnteScript, the concept of extension solves the well known Expression Problem in both Functional Programming and Object Oriented Programming
• An extension generates a new specification from a previous declaration by specifing the specifiction for the additional applications
• An extension generates a new implementation from a previous declaration by specifing the implementation for the additional applications
• A new declaration is typically generated with the new specification and the new implementation
• An extension is checked against duplication of specification attributes and implementation attributes
• In AnteScript, an extension application has the same nature as basic application without any additional limitation (unlike C# extention methods which cannot access private values and do not support polymorphism)

• Notes...

• AnteScript is dynamically typed
• Although AnteScript is dynamically typed, a definition is checked for consistency with its specification before any implmementation is generated and used
• AnteScript supports an Object Oriented Programming form of polymorphism (interface polymorphism) which transparently supports heterogeneous collections
• AnteScript promotes Functional Programming paradigms notably, immutability, referencial transparency, declarative style, composition, point-free style, curying...
• AnteScript does not support inheritance (this is not a lack, this is a feature) except for the relationship between a specification and a definition
• AnteScript does not support overriding (this is not a lack, this is a feature), notably, an invariant application specified in a specification cannot be specified in the associated definition
• In AnteScript, the concept of specification corresponds to the concept of function declaration in Functional Programming
• In AnteScript, the concept of definition corresponds to the concept of function definition in Functional Programming
• In AnteScript, the concept of declaration can ensures the "strong static type safety" criteria of the Expression Problem (by loading separate JavaScript files)
• In AnteScript, composition is simply the concatenation of applications (point-free), for example, to compose the base of the cynlinder with the surface of the circle: (surface_)(base_)(cylinder)
• AnteScript supports multiple-dispatch, the actual code applied depends on more than one argument, for example to add two operands which are either integer, decimal or string: (add_)(operand1)(operand2)
• AnteScript is currently a JavaScript meta-language (the language keywords which names may be freely chosen are actualy JavaScript functions provided by mean of a 350 line JavaScript GUID module)
• AnteScript defines the following keywords: APPLICATION, DECLARATION, SPECIFICATION, IMPLEMENTATION, EXTENSION
• The APPLICATION keyword is used to declare applications, for example in the below example: surface_
• The DECLARATION keyword is used to specify declarations, for example in the below example: cube
• The SPECIFICATION keyword is used to declare specifications, for example in the below example: shape
• The IMPLEMENTATION keyword is used to declare implementations, for example in the below example: cube
• The EXTENSION keyword is used to declare extensions as a special case of specifications and definitions (the Expression Problem is taken into account by the AnteScript language design in a simple and natural way)
• Alternatively, extension may be specified using the optional delegation in the declaration (this mechanism is more versatile than the EXTENSION mechanism but does not ensure that the implementation conforms to the specification)
• An application is typically referenced by a JavaScript variable of the same name (using "const" JavaScript keyword to warn about dulicates or "var" to allow independent specifications sharing the same applications)
• Applications are memoized (calling APPLICATION several times with the same name argument always return the same JavaScript function)
• The current implementation of AnteScript has a large overhead compared to direct JavaScript function calls (linear with the level of applications but constant in the total number of applications)
• AnteScript runtime errors are dealt with by providing an optional custom error function
• AnteScript is currently a proof of concept (the overhead compared to direct JavaScript function calls may impact performance)
• AnteScript is currently implemented using pure functions only (with a significant use of JavaScript WeakMap objects)
• AnteScript could be implemented as a compiled language (obviously, the first compiler would be implemented using the JavaScript version of AnteScript)

• Samples...

• Simple sample...

const shape_ = APPLICATION("shape_");
const label_ = APPLICATION("label_");
const surface_ = APPLICATION("surface_");
const volume_ = APPLICATION("volume_");

const specification = SPECIFICATION([
	[label_],
	[shape_, SPECIFICATION([
		[surface_],
		[volume_],
	])],
]);

const cube = DECLARATION(specification, IMPLEMENTATION([
	[label_, implementation => side => `cube of side ${side}`],
	[shape_, IMPLEMENTATION([
		[surface_, implementation => side => side * side * 6],
		[volume_, implementation => side => side * side * side],
	])],
]));

const sphere = DECLARATION(specification, IMPLEMENTATION([
	[label_, implementation => radius => `sphere of radius ${radius}`],
	[shape_, IMPLEMENTATION([
		[surface_, implementation => radius => radius * radius * Math.PI * 4],
		[volume_, implementation => radius => radius * radius * radius * Math.PI * 4/3],
	])],
]));

const cube1 = cube(1);
const sphere1 = sphere(0.5);

const label1 = (label_)(cube1); // "cube of side 1"
const label2 = (label_)(sphere1); // "sphere of radius 0.5"

const surface1 = (surface_)(shape_)(cube1); // 6
const surface2 = (surface_)(shape_)(sphere1); // 3.141592653589793

const volume1 = (volume_)(shape_)(cube1); // 1
const volume2 = (volume_)(shape_)(sphere1); // 0.5235987755982988
	
// open browser console to see test results...
		

• Extension sample...

const shape_ = APPLICATION("shape_");
const label_ = APPLICATION("label_");
const surface_ = APPLICATION("surface_");
const volume_ = APPLICATION("volume_");

const specificationV0 = SPECIFICATION([
	[label_],
	[shape_, SPECIFICATION([
		[surface_],
		[volume_],
	])],
]);

const cubeV0 = DECLARATION(specificationV0, IMPLEMENTATION([
	[label_, implementation => side => `cube of side ${side}`],
	[shape_, IMPLEMENTATION([
		[surface_, implementation => side => side * side * 6],
		[volume_, implementation => side => side * side * side],
	])],
]));

const sphereV0 = DECLARATION(specificationV0, IMPLEMENTATION([
	[label_, implementation => radius => `sphere of radius ${radius}`],
	[shape_, IMPLEMENTATION([
		[surface_, implementation => radius => radius * radius * Math.PI * 4],
		[volume_, implementation => radius => radius * radius * radius * Math.PI * 4/3],
	])],
]));

const invariant_ = APPLICATION("invariant_");
const stretch_ = APPLICATION("stretch_");

const specificationV1 = EXTENSION(specificationV0)(SPECIFICATION([
	[shape_, SPECIFICATION([
		[invariant_, implementation => Math.pow((volume_)(shape_)(implementation), 2) / Math.pow((surface_)(shape_)(implementation), 3)],
		[stretch_],
	])],
]));

const cubeV1 = DECLARATION(specificationV1, EXTENSION(cubeV0)(IMPLEMENTATION([
	[shape_, IMPLEMENTATION([
		[stretch_, implementation => side => k => cube(side * k)],
	])],
])));

const sphereV1 = DECLARATION(specificationV1, EXTENSION(sphereV0)(IMPLEMENTATION([
	[shape_, IMPLEMENTATION([
		[stretch_, implementation => radius => k => sphere(radius * k)],
	])],
])));

const cylinderV1 = DECLARATION(specificationV1, IMPLEMENTATION([
	[label_, implementation => (radius, height) => `cylinder of radius ${radius} and height ${height}`],
	[shape_, IMPLEMENTATION([
		[surface_, implementation => (radius, height) => radius * radius * Math.PI * 2 + height * radius * Math.PI * 2],
		[volume_, implementation => (radius, height) => height * radius * radius * Math.PI],
		[stretch_, implementation => (radius, height) => k => cylinder(radius * k, height * k)],
	])],
]));

const cube = cubeV1;
const sphere = sphereV1; 
const cylinder = cylinderV1; 

const cube1 = cube(1);
const cube2 = (stretch_)(shape_)(cube1)(2);
const sphere1 = sphere(0.5);
const sphere2 = (stretch_)(shape_)(sphere1)(2);
const cylinder1 = cylinder(0.5, 1);
const cylinder2 = (stretch_)(shape_)(cylinder1)(2);

const label1 = (label_)(cube1); // "cube of side 1"
const label2 = (label_)(cube2); // "cube of side 2"
const label3 = (label_)(sphere1); // "sphere of radius 0.5"
const label4 = (label_)(sphere2); // "sphere of radius 1"
const label5 = (label_)(cylinder1); // "cylinder of radius 0.5 and height 1"
const label6 = (label_)(cylinder2); // "cylinder of radius 1 and height 2"

const surface1 = (surface_)(shape_)(cube1); // 6
const surface2 = (surface_)(shape_)(cube2); // 24
const surface3 = (surface_)(shape_)(sphere1); // 3.141592653589793
const surface4 = (surface_)(shape_)(sphere2); // 12.566370614359172
const surface5 = (surface_)(shape_)(cylinder1); // 4.71238898038469
const surface6 = (surface_)(shape_)(cylinder2); // 18.84955592153876

const volume1 = (volume_)(shape_)(cube1); // 1
const volume2 = (volume_)(shape_)(cube2); // 8
const volume3 = (volume_)(shape_)(sphere1); // 0.5235987755982988
const volume4 = (volume_)(shape_)(sphere2); // 4.1887902047863905
const volume5 = (volume_)(shape_)(cylinder1); // 0.7853981633974483
const volume6 = (volume_)(shape_)(cylinder2); // 6.283185307179586

const invariant1 = (invariant_)(shape_)(cube1); // 0.004629629629629629
const invariant2 = (invariant_)(shape_)(cube2); // 0.004629629629629629
const invariant3 = (invariant_)(shape_)(sphere1); // 0.008841941282883074
const invariant4 = (invariant_)(shape_)(sphere2); // 0.008841941282883074
const invariant5 = (invariant_)(shape_)(cylinder1); // 0.005894627521922049
const invariant6 = (invariant_)(shape_)(cylinder2); // 0.005894627521922049
	
// open browser console to see test results...
		

• Polymorphism sample...

const shape_ = APPLICATION("shape_");
const label_ = APPLICATION("label_");
const surface_ = APPLICATION("surface_");
const volume_ = APPLICATION("volume_");

const specificationV0 = SPECIFICATION([
	[label_],
	[shape_, SPECIFICATION([
		[surface_],
		[volume_],
	])],
]);

const cubeV0 = DECLARATION(specificationV0, IMPLEMENTATION([
	[label_, implementation => side => `cube of side ${side}`],
	[shape_, IMPLEMENTATION([
		[surface_, implementation => side => side * side * 6],
		[volume_, implementation => side => side * side * side],
	])],
]));

const sphereV0 = DECLARATION(specificationV0, IMPLEMENTATION([
	[label_, implementation => radius => `sphere of radius ${radius}`],
	[shape_, IMPLEMENTATION([
		[surface_, implementation => radius => radius * radius * Math.PI * 4],
		[volume_, implementation => radius => radius * radius * radius * Math.PI * 4/3],
	])],
]));

const invariant_ = APPLICATION("invariant_");
const stretch_ = APPLICATION("stretch_");

const specificationV1 = EXTENSION(specificationV0)(SPECIFICATION([
	[shape_, SPECIFICATION([
		[invariant_, implementation => Math.pow((volume_)(shape_)(implementation), 2) / Math.pow((surface_)(shape_)(implementation), 3)],
		[stretch_],
	])],
]));

const cubeV1 = DECLARATION(specificationV1, EXTENSION(cubeV0)(IMPLEMENTATION([
	[shape_, IMPLEMENTATION([
		[stretch_, implementation => side => k => cube(side * k)],
	])],
])));

const sphereV1 = DECLARATION(specificationV1, EXTENSION(sphereV0)(IMPLEMENTATION([
	[shape_, IMPLEMENTATION([
		[stretch_, implementation => radius => k => sphere(radius * k)],
	])],
])));

const cylinderV1 = DECLARATION(specificationV1, IMPLEMENTATION([
	[label_, implementation => (radius, height) => `cylinder of radius ${radius} and height ${height}`],
	[shape_, IMPLEMENTATION([
		[surface_, implementation => (radius, height) => radius * radius * Math.PI * 2 + height * radius * Math.PI * 2],
		[volume_, implementation => (radius, height) => height * radius * radius * Math.PI],
		[stretch_, implementation => (radius, height) => k => cylinder(radius * k, height * k)],
	])],
]));

const cube = cubeV1;
const sphere = sphereV1; 
const cylinder = cylinderV1; 

const cube1 = cube(1);
const cube2 = (stretch_)(shape_)(cube1)(2);
const sphere1 = sphere(0.5);
const sphere2 = (stretch_)(shape_)(sphere1)(2);
const cylinder1 = cylinder(0.5, 1);
const cylinder2 = (stretch_)(shape_)(cylinder1)(2);

const definitions = [ 
	cube1,
	cube2,
	sphere1,
	sphere2,
	cylinder1,
	cylinder2,
];

const labels = definitions.map(definition => (label_)(definition));
// labels[0] === "cube of side 1"
// labels[1] === "cube of side 2"
// labels[2] === "sphere of radius 0.5"
// labels[3] === "sphere of radius 1"
// labels[4] === "cylinder of radius 0.5 and height 1"
// labels[5] === "cylinder of radius 1 and height 2"

const surfaces = definitions.map(definition => (surface_)(shape_)(definition));
// surfaces[0] === 6
// surfaces[1] === 24
// surfaces[2] === 3.141592653589793
// surfaces[3] === 12.566370614359172
// surfaces[4] === 4.71238898038469
// surfaces[5] === 18.84955592153876

const volumes = definitions.map(definition => (volume_)(shape_)(definition));
// volumes[0] === 1
// volumes[1] === 8
// volumes[2] === 0.5235987755982988
// volumes[3] === 4.1887902047863905
// volumes[4] === 0.7853981633974483
// volumes[5] === 6.283185307179586

const invariants = definitions.map(definition => (invariant_)(shape_)(definition));
// invariants[0] === 0.004629629629629629
// invariants[1] === 0.004629629629629629
// invariants[2] === 0.008841941282883074
// invariants[3] === 0.008841941282883074
// invariants[4] === 0.005894627521922049
// invariants[5] === 0.005894627521922049
	
// open browser console to see test results...