5 Standard Logix

Standard Logix is a Logix-defined language like any other. It is the language that the shell starts up in by default. This section describes Standard Logix and its various operators.

Standard Logix is experimental! It is likely to go through many upheavals before becoming a stable language. One of the great strengths of a meta-language like Logix is that it supports this kind of iterative, organic language design.

Standard Logix has a fairly transparent translation into Base Logix, and hence into Python. It feels very much like programming Python with a different syntax. If you don’t know Python, you are strongly recommended to learn some before programming Standard Logix.

The implementation of Standard Logix can be found in logix/std.lx (at the time of writing, just 324 lines of code)

5.1 Python Basis

Standard Logix inherits all of the operators from Base Logix (Logix’s Python-like language). In other words, pretty much everything you know from Python is available just the same in Standard Logix, unless stated otherwise in this section (e.g. the function-call syntax is different).

5.2 Function Calls

Function calls are simply a sequence of expressions:

Nested function calls need to be parenthesized.

There’s nothing special going on with these parentheses – they are simply grouping the call to min, just as you would use parentheses in any expression. Parentheses are not part of the function call syntax as they are in Lisp, Python and many other languages.

The function itself can be the result of an expression:

Zero argument functions are called with a special postfix operator ()

This is not empty parentheses, it is a special operator.

5.3 Keyword Arguments

Keyword arguments are supported, with semantics equivalent to Python

5.4 Lists

List syntax is like Python's.

List comprehensions are available.

A compact syntax is available for simple numeric ranges (it returns a Python xrange)

List subscripts cannot use the same syntax as Python – it would conflict with the function-call syntax, e.g.:

is in fact a call to the function myList with one argument, the list [3]. List subscripts instead look like this:

There must not be a space between the / and the [. Slices are similar:

Logix introduces a data-type called an flist – a ‘field list’. It is a list that also contains named elements. It is somewhat like a combination of a list and a dict. In Standard Logix, if a list literal contains named fields, an flist is returned instead of a list.

The list comprehension is similarly extended to support flists.

This always produces an flist with no elements. A list and an flist can be added together (+ operator) to overcome this.

5.5 Dictionaries

Syntax for dictionaries differs from Python (although, confusingly, dicts still display using Python syntax – hey, it’s alpha!)

The empty dict is written:

Logix also has dict comprehensions – just add a colon to the regular list comprehension syntax:

As with Python, setting and getting dict entries uses the same syntax as list indexing.

For the common case where the keys of a dict are names, a convenience operator is provided.

The divide operator is renamed to div (it is still infix).

5.6 Object Attributes

The traditional ‘.’ operator is available, but with some additional smarts. Firstly it is a smartspace operator. Smartspace is a Logix feature that allows white-space around operators to effect the scope of the operator. The motivation for using smartspace is that without it, OO expressions in Standard Logix can be awkward. Consider for example the following Python expression:

In Standard Logix, you might write that

Which is much less readable than the Python version. Would it look better without the parentheses?

That looks all wrong – it looks like you are trying to do the following.

In fact, that is how it is parsed (we’ll see the correct way to write it momentarily).

By using a smartspace operator, OO statements are much easier to read. When there is no space around the ‘.’, parentheses are implied. For example, these two are equivalent:

Whereas the previous example must be written:

The space before the ‘.’ causes the expression to be parsed the same as the original Python. This style may be unfamiliar, but it quickly becomes very easy to both write and read.

The ‘.’ operator has some extra features. The equivalent of getattr can be achieved like this

It is relatively common to need to test on an object field, where the object reference may be None, like this:

Standard Logix provides a convenience operator .? for this situation. The following is entirely equivalent:

5.7 Sequence Operators

Some of the basic operators have variations for convenient operations on sequences.

seq.*f                     is equivalent to    [x.f for for x in seq]

seq/*[key]           is equivalent to         [x/[key] for x in seq]

seq/*foo                is equivalent to         [x/foo for x in seq]

a ,* b ,* c         is equivalent to         zip a b c

5.8 Defining Functions

Function definitions look like Python without the parentheses or commas:

The return is in fact not required. Without it, the result of the function is the result of the last statement in the function body.

5.8.1 Argument Preconditions

Standard Logix allows argument preconditions to be defined inside the argument list. A precondition can either be

• a type, in which case an isinstace check is performed, or
• A predicate function that tests if the value is valid

Using Logix’s multiple language capabilities, the argument precondition is actually an expression in a special purpose language. This language is currently not very developed – it has only one operator. The ? operator is used to indicate that None is a valid argument. E.g. this function must be passed an Employee:

While this one can be passed an Employee or None

(note that in many languages, including Java, the null value matches any type. In Python and hence in Logix, None is an instance of NoneType and matches no other type)

In the future there will be other operators, e.g. for conjoining and disjoining argument predicates.

5.9 Lightweight Lambdas

There is a nice lightweight syntax for anonymous functions:

For example

In the common case where there is only a single argument, the argument spec can be omitted. The single argument is called it.

5.10 Variable Function Arguments

Just as in Python, functions can receive variable arguments and variable keywords:

The calling syntax has to be slightly different to Python’s, to avoid ambiguity with the * and ** operators.

5.11 Testing Lists: forany and forall

The forall operator evaluates true if the test holds for all elements of a list:

Notice that as with list comprehensions, list elements can be extracted into any valid assignable place (here we unpacked a pair into two variables).

The forany operator has deeply mysterious semantics that I doubt anyone will be able to fathom:

forall will stop iterating as soon as a test evaluates false. forany will stop iterating as soon as any test evaluates true.

5.12 Building Lists: listfor and listwhile

List comprehensions are great for succinctly building lists within expressions, but sometimes they don’t suffice, particularly if a temporary value is needed.

The listfor and listwhile operators are just like for and while, except they have a result:  a list made from the result of the loop body for each iteration (the result of the loop body is the result of the last expression). The operators also have an if clause similar to that found in list comprehensions.

Say you wanted to do:

With list comprehensions, you can't avoid calling split twice. With listfor it looks like

5.13 Scanning Lists: valfor and breakwith

It is common to use a for loop to search a list for a particular value, break-ing out of the list when the value is found. Python provides a very useful else clause that can be used to provide a default when the value is not found:

This however, is typical ‘inside out’ imperative programming – it is not clear that the whole construct is simply assigning a value to result.

For this situation, Logix provides valfor, to be used in conjunction with breakwith.

The construct is useful, but the keywords valfor and breakwith are rather clumsy – they are liable to change.

5.14 Function Pipelines

Python programmers have generally found list comprehensions to provide a nicely readable alternative to the map function, especially when multiple steps are required. For example, without list comprehensions, an expression like

requires something like

or

Neither are very pleasing to read. Logix provides another alternative which is both clear and concise: an infix map operator. With this operator, expressions read like a ‘pipeline’.

In other words “pipe l through str, and then len”.

In a similar vain, ?> filters a list according to a predicate function, and .> simply applies a function to a single value. Here is a pipe that uses all three.

Such expressions have the advantage that the order of operations reads left to right. The equivalent list comprehension reads backwards:

5.15 Timing code

A minor but handy feature is provided for timing code. The do operator can be given a timed clause, with a message.

5.16 String Literals