#caskeda

Definitions... Abstractions... confused? Me too! This is just a note. If you think something isn't right with the logic below, tell me! :)

Instance

A concrete 'thing' that has attributes/properties that can be operated on and functions that do something with it. Any and all instances have a 'type'. (Too abstract?)

Instance Binding

A slot/bucket/clamp that a instance can be put into. There are several types of instance bindings:

Managed Bindings

The lifecycles of instances in a managed binding are controlled by a 'garbage collector' at runtime. There is a small (usually neglible) overhead for these instances at runtime in both memory and execution speed.

Retained Bindings

The lifecycles of instances in a retained binding are controlled by a small set of rules that are enforced at compile time.

Unbounded Bindings

The lifecycles of instances in a unbounded binding are not controlled at all. Because of this, using them is only permitted inside sections of code explicitely marked as unsafe.

Type

A type is the 'description' or 'definition' of how a instance looks like (both internally and externally) and how it behaves.

Reference

A reference is a key/link to an instance. Internally, this is always a pointer of some kind.

?-structors

constructor: Given a tuple of instances, create a new (more complex) instance out of them.

deconstructor: Given a instance of some type, turn it into a new tuple.

reconstructor: Given a instance of one type, create a new instance of some other type.

destructor: Given a instance, perform actions before the instance ceases to exist.

Nothing

Literally nothing. It is a special instance binding that does not hold any attributes, values, properties, etc. etc.

Function

A function takes one or more references, does something, and then returns a reference, instance binding or Nothing as a result.

Pure Function

A function that only takes explicit parameters as input. There are no hidden variables or state. In reality, such functions can not exist, but for the sake of abstraction they do.

Method

A method is a function directly associated with the type of an instance. It can not be used (/called) without having a instance of that type.

Operator

A operator is a special function that is called by writing a specific symbol (or combination thereof) inside a expression.

Expression

A tree (or sequence) of operators and references that performs a calculation and returns a instance binding, reference or Nothing.

Statement

A command. A expression. A change in control flow. Execution.

Syntax

The grammar of a programming language.

Standard Library

A collection of functions and types that build a base for users of a programming language to build on to.

Testing if Bird's can fly...

function main { console.init(); console.print("Constraint solver test."); // Create a type 'Bird'. type Bird; // Create a type property 'wounded' without type. type property wounded : Nothing; // Define a set of values... let john = Bird.new { wounded }; let mary = Bird.new; // Set up logic... bind isBird(x) = x instanceof Bird; bind isAbnormal(x) = x.has wounded; bind canfly(x) = isBird(x) & !abnormal(x) // Solve! console.print(canfly(john)); // false console.print(canfly(mary)); // true }

Sorting some Sheep...

function main { // Define a type 'Sheep'. type Sheep; // Define properties. type property colour : enum(WHITE,BLACK,RAINBOW); // Define a set of values... let A = Sheep.new {colour=WHITE}; let B = Sheep.new {colour=RAINBOW}; let C = Sheep.new {colour=BLACK}; let l = (A,B,C); // This defines a sorting function that will take a // collection of Sheep indexed by integers, sort it // according to the constraints defined below, then // return a new collection of Sheep indexed by integers. bind rules : ([Int]Sheep) -> ([Int]Sheep) [ // 'where any: left.colour not BLACK' true: [-1].colour != BLACK; // 'where colour == RAINBOW: position not 0' _.colour == RAINBOW: [_] != 0; ] // print 'before' console.print(l); // solve l = rules( l ); // print 'after' (result) console.print(l); }