Category:Quackery

Quackery
This programming language may be used to instruct a computer to perform a task.

See Also:	Quackery on the HOPL

Listed below are all of the tasks on Rosetta Code which have been solved using Quackery.

Quackery is an open source, lightweight, entry level concatenative language for educational and recreational programming.

It is coded as a Python 3 function in under 48k of Pythonscript, about half of which is a string of Quackery code.

The Quackery GitHub repository, which includes the Quackery manual "The Book of Quackery" as a pdf, is at github.com/GordonCharlton/Quackery.

About Quackery[edit]

The Quackiverse consists of operators (i.e. op-codes or "primitives"), numbers (BigInteger) and nests (dynamic arrays of operators, numbers and nests). They reside on either of two stacks, or in one of the two dictionaries of named items (operators, numbers and nests) that the Quackery compiler, build, uses to translate written Quackscript into nests that can be evaluated with do, the default behaviour, or added to either of the dictionaries.

  [ build do ] is quackery

Quackery in a nutshell.

To compile this definition of quackery, build takes a string of Quackscript and turns it into a nest. The left and right brackets delimit a nest, which will contain pointers to the dictionary items called build and do, in that order. Quackery code is evaluated from left to right, one item after another, traversing a tree of nests in depth first order. Once build has compiled the string, it passes the resultant nest via the Quackery stack, which is used to carry arguments and results from one word to the next, to do for evaluation. The second stack, the return stack, manages do's depth first traversal of nested nests.

The words is, [, and ] are builders; they can be found in the builders dictionary, which extends the functionality of build beyond building a flat nest for do to evaluate. is takes the item that do most recently added to its output nest, and adds it to the names dictionary, along with the string that follows it, "quackery" as its name. The syntax of Quackery is; words and numbers are sequences of printable characters, separated by spaces and carriage returns unless a builder treats the text that follows it otherwise. The builder builds is equivalent to is for adding new words and behaviours to the builders dictionary.

Evaluation of a nest proceeds from left to right unless a control flow operator redirects it. done causes doto stop evaluating a nest and return to the nest that pointed to it immediately, rather than at the end of the nest. again restarts the evaluation of that nest, non-recursively. The word recurse does it recursively. if and iff conditionally (depending on the item on the top of the Quackery stack) skip over the next one and two items in the nest respectively. else skips over one item, unconditionally. As with the other provided control flow operators, these words are nests, not operators, that make use of the "meta-control flow" operators, which grant the behaviours described above to words that use them. (They modify items on the return stack, rather than acting on the Quackery engine's various pointers registers directly, so their changes are enacted upon exiting the nest that called them.)

There are no variables in Quackery. Instead there are stack management words to rearrange the uppermost items on the Quackery stack as required, and nameable ancillary stacks that fulfil the roles of variables.

Everything is code except when it is data. When do does a number, the behaviour of the number is to put its numerical value on the stack. Operators do the heavy lifting; there are operators that treat numbers as integers, or as booleans, or as sequences of bits, or as characters, and there are operators to edit nests, interface with the real-world host computer for I/O, and so on. Nests give structure to code and data alike.

Conceptually, the Quackery engine is a stack based processor which does not have direct access to physical memory, but has a memory management co-processor that intermediates, that takes care of the nests and bignums, provides pointers to the Quackery engine CPU on request, and garbage collects continuously.

Quackery is not intended to be a super-fast enterprise level language; it is intended as a fun programming project straight out of a textbook. (The textbook is included in the download.)

If your language supports bignums, first class functions and dynamic arrays of bignums, functions and dynamic arrays, and has automatic garbage collection, and if you can code depth first traversal of a tree, you can implement Quackery in your preferred language with reasonable ease, and modify it as you please.