Red functions for Python programmers - red/red GitHub Wiki

Slicing

List comprehensions

The code, provided in this article for the cases when Red does not have a corresponding function to the Python one, just demonstrates a possible solution. All these functions are written in pure Red (mezzanine functions). If the performance is of greatest importance, they can be written in Red/System (which is outside the scope of this article)

length?

Python

len(s) returns the length (the number of items) of an object. The argument may be a sequence (such as a string, bytes, tuple, list, or range) or a collection (such as a dictionary, set, or frozen set)

Red

length? returns the number of values in the series!, from the current index to the tail , or the number of elements needed to store the value, if it is of one of the following types: port! bitset! map! tuple! none!.

(series! is a typeset! consisting of the following datatypes: block! paren! string! file! url! path! lit-path! set-path! get-path! vector! hash! binary! tag! email! image!)

In the last example file has a value of file! datatype. File! values represent file names or directory names and paths. File! is a member of the following typesets: any-string!, series!, so it is kind of string. length? file returns the length of the string representing the file name and not the size of the file it may refer to.

The length of an image! value is the number of its pixels:

The above examples showed the length of values that are series!. Let’s see how it works with the other supported datatypes.

The length of the bitset! is computed as the smallest multiple of 8 needed to fit the highest bit number (0-origin):

The length of a map! value is the number of its keys:

The length of a tuple is the number of its elements:

If you wonder the purpose of the question mark at the end of length? - here’s the answer:

Function names should strive to be single-word verbs, in order to express an action. . . A noun or an adjective followed by a question mark is also accepted. Often, it denotes that the return value is of logic! type, but this is not a strict rule, as it is handy to form single-word action names for retrieving a property (e.g. length?, index?)

print

Python

print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False) Print objects to the text stream file, separated by sep and followed by end. sep, end, file and flush, if present, must be given as keyword arguments.

Red

print outputs a value followed by a newline. If the argument is a single value, there is no need to enclose it in brackets.

When the argument is a block!, print reduces it before ouput:

Of course all the values in a block we want to print must have values:

You can still print the block from the example above – you first need to mold it (to get its source format string representation):

In fact Red does have a built-in function that does exactly the same - probe:

In addition, probe returns the printed value:

When you don’t want the printed output to end with a new line, use prin instead of print:

Sometimes you need a new line to be inserted between the values of a single call to print. The newline character in Red is indicated by #"^/". There are two words predefined to this value: newline and lf:

String Formatting

Python

The format() method formats the specified value(s) and insert them inside the string’s placeholder. The placeholder is defined using curly brackets: {}. The values are passed as positional and/or keyword arguments. Inside the placeholders you can add a formatting type to format the result, like alignment and number formats.

Red

Red doesn’t currently have a single function that can mimic Python’s format(). In most simple cases you can use rejoin:

Here’s a simple function that formats a string. It takes a string as its first parameter and sets the placeholders to the corresponding named values found in the second argument – a block with “keyword” parameters:

We can add some formatting types to the above function and make it more useful. Here’s a tiny formatting DSL.

There is much more sophisticated experimental Red dialect dedicated to formatting: Red-formatting

Type checking

Python isinstance(object, type) returns True if the specified object is of the specified type, otherwise False.

Red

Red doesn’t have a single function to check if a value is of the specified type. Instead, there is a separate function for each datatype and typeset. This is similar to Racket’s predicate functions.

It is very easy to write an isinstance function in Red:

The type can be a single datatype, a typeset or a block of datatypes (can be unrelated types).

Here are some tests:

String representation of an object

Python

str(object, encoding=encoding, errors=errors) converts the specified value into a “readable” string.

Red

While not 100% equivalent to Python’s str(), form is Red’s way to give a user-friendly string representation of a value.

Note that the result of form is ambiguous – like Python’s str() - both integer 123 and string “123”` are formed as ”123”. The same is in Python:

That means that the result of form can’t always be loaded back to the original type of the value.

Conversion to integer

Python

int(x, base=10) returns an integer object from a number or string. If base is given, then x must be a string, bytes, or bytearray instance representing an integer literal in radix base.

Red

Use to-integer value to convert a number!, char!, string! or binary! value to integer:

to-integer is an alias for to integer!. It can be further shortened to to 1 - you can use any other integer instead of 1, as well as a word that refers to an integer value.

Red has a pair of functions - enbase and debase that convert to/from binary-coded string. They support bases 64 (default), 58, 16 and 2. The base can be changed using the /base refinement.

enbase accepts binary! and string! values:

As you can see, in order to convert a number to base 2 representation, we first need to convert it to binary!.

Lets’ convert the last result back to an integer:

Please note that the binary-coded strings in base 2 are left-padded with zeroes to a length multiple of 8. So our previous example could have been like this (imagine you import the binary data from the outside):

Red doesn’t currently provide a function for integer conversion from arbitrary number bases different than 10, but it is an easy task:

Here are some tests:

Ranges

Python

The range type represents an immutable sequence of numbers and is commonly used for looping a specific number of times in for loops.

range(stop) or range(start, stop[, step])

Red

Red doesn’t have a built-in solution that covers the functionality of Python’s range() sequence. It is easy to write a function that generates a list of numbers in a range, that is Python’s list(range(x)). Here’s one way to do it:

Here are some tests:

Here’s a more elaborated Range function for multiple datatypes

Puthon’s range() returns an immutable sequence and can be used directly with for, zip, enumerate and other constructs/functions. It can also be passed to iter() and then its elements accessed sequentially with next() until exhaustion. A range object can be converted to a list with list().

Lets’ try to make a function lazy-range in Red that does not generate the entire list at once but create a range object. lazy-range will accept the same arguments as our earlier range function. It returns a single element when request with /next?. The /size field contains the total number of elements. Unlike Python, I added a /reset field that resets the current element to the starting value. There is also a /list field that generates a list of all the elements in the range from the current element to the end.

Let’s make some tests:

Open file

Python Open file and return a corresponding file object. If the file cannot be opened, an OSError is raised.

Red In Red you don’t need to make a call to a special function to open a file, you just do what you need with the file – read, write and so on. The binary mode is indicated with /binary refinement.

List cosntructor

Python

list() takes an iterable object as input and adds its elements to a newly created list.

Red

to-block conversion does similar job for some datatypes – it is convenient to use with map! and path! values:

Here’s a simple function that takes a value and returns a block of values:

Let’s do some tests with compound and scalar datatypes:

Super

Python

The super() function returns a temporary object of the parent class that allows access to all of its methods to its child class.

Red

Objects in Red are based on prototypes and not on classes – that’s why there is no need of Python’s super() in Red.

Sets

Pyton set() returns a new set object, optionally with elements taken from an iterable.

Red

Red doesn’t currently have a separate set datatype, but provides several functions for working with data sets with no duplicates. We can make a set from a series using unique:

color-set is still a block! (with the duplicates removed) and not a set object like in Python. We can append an existing value to it:

For comparison, Python’s add() method adds a given element to a set if the element is not present in the set.

Associative arrays

Python

dict() creates a new dictionary initialized from an optional positional argument and a possibly empty set of keyword arguments.

Red

Red uses map! datatype to represent associative arrays of key/value pairs. Except using literal syntax #[<key> <value>…​], a map! value can be created from a block, with to-map conversion, resembling Python’s dict() used with a set of keyword arguments:

Get an attribute of an object

Python

getattr(object, name[, default]) returns the value of the named attribute of object; name must be a string. getattr(x, 'foobar') is equivalent to x.foobar. If the named attribute does not exist, default is returned if provided.

Red

Values of objects fields are referenced using path notation in Red. An alternative is to use the get function:

If we want to recreate the Python’s getattr() function and specify the attribute as a string, we need to use approach from the last example:

Please note that getattr errors for keys that don’t exist, as seen from the last example. We can change our function to return none for non-existing keys by replacing get in with select:

Let’s test it with the same object and a key that is not present in it:

Check if an object has a given attribute

Python hasattr(object, name) accepts an object as its first argument and a string for its second one. Returns True if the strings is the name of one of the object’s attributes, False if not.

Red

Red doesn’t have such a function, but is easy to implement one. We can do it in Python’s manner, where hassattr() calls getattr(object, name) and sees whether it raises an AttributeError or not:

We can do it in another, way, checking the words-of the object for the attribute, converted to word:

This method is “heavier” though, as it has to build the block of words.

Get the type a word refers to

Python

type() - when called with one argument, returns the type of an object. With three arguments, return a new type object.

Red

type? returns the datatype of a value. If used with the /word refinement, returns a word! value instead of a datatype!:

Please be cautious when forming the results of type. Note the difference in the form ed representation of type? and type?/word:

Convert string to a floating point number

Python

float([x]) returns a floating point number constructed from a number or string x.

Red

to-float converts to float! value.

Enumerating iterables

Python

enumerate(iterable, [start=0]) returns an enumerate object. iterable must be a sequence, an iterator, or some other object which supports iteration. The next() method of the iterator returned by enumerate() returns a tuple containing a count (from start which defaults to 0) and the values obtained from iterating over iterable.

Red

Red doesn’t have a function similar to enumerate(), but let’s try to write one:

enumerate takes a series as its argument and returns an object. That object’s next field is a function that consumes an element of the series and uses the element along with a counter to create a block, that is returned to the user. The starting index can be set using the /start refinement.

Here are some examples:

As you see, /next returns none when the series is exhausted.

enumerate works with other series! too:

Sorting

Python

sorted(iterable, *, key=None, reverse=False) returns a new sorted list from the items in iterable. key specifies a function of one argument that is used to extract a comparison key from each element in iterable

Red

Similarly to Python’s sort() method, Red’s sort sorts the series in place. When we need to preserve the ordering of the original series, we can use sort copy:

More details on sort can be found here

Finding the maximum of two values or the largest item in a series

Python

max() returns the largest item in an iterable or the largest of two or more arguments.

Red

Red’s max function accepts exactly two arguments and returns the greater of the two values. Here is an example of function that returns the maximum value in a series:

It expects a series! for its argument. If no refinement is used, the function uses greater? to compare the values. If the /compare refinement is used with an integer! argument, the first argument must be a block of blocks and the n-th values in each block are compared using greater?. If the argument for /compare is a function, then the values are compared using this function. The function must have arity two and must return a logic! value. Here are some tests:

*Printable representation of values/objects *

Python

repr() returns a printable representation of the given object. For many types, this function makes an attempt to return a string that would yield an object with the same value when passed to eval(), otherwise the representation is a string enclosed in angle brackets that contains the name of the type of the object.

Red

mold returns a source format string representation of a value.

Please note the difference between form and mold - the result of mold can (in most cases) be loaded back to a value equal to the original one.

Aggregating elements from iterables (series)

Python

zip(*iterables) makes an iterator that aggregates elements from each of the iterables.

Red

Red doesn’t currently have a zip function.

Here is a simple zip function that reurns an object (let’s call it a zip object). The zip object has two function fields: /next returns the next tuple, formed by the series values. /list creates a block of blocks (tuples) from the current position in the series until the exhaustion of the shortest series.

Let’s test it:

The above solution has a side effect though – you can access the zip object’s iter field (the intermediate block before zipping) from the outside, without a function call. If we want to encapsulate it, we can go for a different solution that uses an internal map! to store the series to be zipped.

Here are some tests:

The above zip function has one argument when called without any refinement, id, which must be of ` word!` type. It will be used as a reference, as well as for a key in the function’s internal map that stores the data for the different calls. Note that it is initialized simply by buf: []. Since there is no copy in from of [], the contents of the map will persist between the function calls.

When called with the /init refinement, the function expects in addition to the id argument a block of blocks that are to be zipped. If you need to zip two blocks – let’s say names and addresses, you need to supply them to zip as follows: zip/init 'person reduce [names addresses]. This will add a new person key to the zip’s internal map, with value – a block containing the names and addresses blocks. The map can’t be accessed from outside the function.

We can get the successive tuples (blocks) by calling zip ‘person. When there are no elements left in any one of the blocks, zip will return none. Note that the element extraction is done using take - that means the data is destructed and can be referenced only once.

When zip is used with the /list refinement, the function collects all the zipped tuples in a block and returns it as a result: zip/list 'person.

Creating immutable sequences

Python

Tuples are immutable sequences, typically used to store collections of heterogeneous data (such as the 2-tuples produced by the enumerate() built-in). tuple(iterable) constructor builds a tuple whose items are the same and in the same order as iterable’s items. iterable may be either a sequence, a container that supports iteration, or an iterator object.

Red

Red doesn’t have a function similar to Python’s tuple() - values of composite types in Red are mutable.

Red tuple! datatype is used to represent RGB and RGBA color values, ip addresses, and version numbers. A tuple! value consists of three to twelve positive integers the range 0 – 255 separated by decimal points.

Mapping functions to blocks/lists

Python

map(function, iterable, …​) returns an iterator that applies function to every item of iterable, yielding the results. If additional iterable arguments are passed, function must take that many arguments and is applied to the items from all iterables in parallel. With multiple iterables, the iterator stops when the shortest iterable is exhausted.

Red

Red doesn’t currently have a map function (Higher Order Functions are in making). In many cases a solution involving collect / keep and foreach (or forall) is sufficient. Let’s try to make one.

I’ll first introduce an additional function, reduce-by:

accumulate is similar to Python functools’ reduce(). It is introduced to facilitate the way we determine the shortest series in the cases when we map a function to several series at once.

We can demonstrate its use by the following example:

Here we accumulate the sum of the values 1 through 4, starting with 0.

Here is the map function itself:

The first argument to map is the series we want to apply the fn function (second argument) to. The optional argument – the refinement /only instructs the function that the series is treated as a block of blocks; the arity of fn must match the number of elements in the series.

Let’s first test map with a function of one argument:

length? is applied to each string in the block and the partial results are collected and then returned.

Here are two test of map using the only refinement:

In the first example we simply add up the corresponding numbers in two lists. Please note that the length of the result is equal to the length of the shortest of the two input lists.

The second example demonstrates the use of a user-defined function of 3 arguments - suffix-has - that checks if the last len characters of src include char. We call map/only with a block of three blocks as its series argument and :suffix-has for its fn argument.

Finding the smallest of two values or the smallest item in a series

Python

min() returns the smallest item in an iterable or the smallest of two or more arguments.

Red

Red’s min function accepts exactly two arguments and returns the smaller of the two values.

Here is a min-series function that returns the smallest item in a series (it is almost identical to our previous max-series function – the only important difference is the choice of the default comparator - lesser? instead of greater?):

Let’s do a trivial test:

The test below demonstrates the use of the /compare refinement. The comparator function cmp-sum returns true if the sum of the numbers in the first argument is lesser than the sum of the items of the second argument. This way min-series will return the block with the smallest sum:

Slicing

Python supports slice notation for any sequential data type like lists, strings, tuples, bytes, bytearrays, and ranges. Slicing is a flexible tool to build new lists out of an existing list.

Red doesn’t have a built-in slicing mechanism. Here is a function that achieves similar results. Please note that Red uses 1-based indexing. start and stop create an inclusive range. The syntax is as follows:

slice series spec, where series`is a series! value and `spec is a block of optional start, stop and step values, separated by / (: has a special meaning in Red associated with set-word! and get-word! types).

We can test the slice function as follows:

List comprehensions

List comprehensions provide a concise way to create lists. Common applications are to make new lists where each element is the result of some operations applied to each member of another sequence or iterable, or to create a subsequence of those elements that satisfy a certain condition.

Red doesn’t currently have built-in list comprehensions. Here is a simple function that takes a block as specification and returns a new list generated according the rules in the specification. You don’t need to understand this code, just note how little code it takes to extend Red at the user level, in a way that works like a native language feature.:

The spec block has the following syntax: [expr | id: block … <? cond …>]

expr is an expression that uses the value of id1 (and possibly all other identifiers). id is a set-word! that gets the values of block one after another. If there are more than one id and block, the function goes through all the possible Cartesian products of the values. cond is an optional condition(s) that must be true for the current value(s) of id(s) in order for the function to apply expr to the value(s) and keep the result in the output series. The expression is separated by the id: block part by |, and the condition part is marked with ?. Here are some test of the list-comp function:

The list-comp function works by parsing the spec block, extracting the expr, id: block and cond parts, generating Red code based on the collect / foreach / keep pattern and evaluating the code. The code itself makes a block (of blocks if necessary) that is returned as result. The drawback is that the entire resulting block is kept in RAM.

We can create a generator-like function that doesn’t take additional memory for the result, but instead yields the current item upon request.

The first call to gen-list must be with the /init refinement – it will create a record in the functions’s internal map for the id that is provided. The next calls should be just gen-list 'id:

The gen-list function processes the spec in a way similar to the previous list-comp function. The difference is that when called with /init, it registers a new entry into its internal map with key the id and value – an object for the provided specification. The object contains a block of the series identifiers, the series themselves, a block with the lengths of each series and a function to be evaluated for each set of values.

As I said, the function doesn’t create an entire block at once, but yields a single value for each value in the original block (or each item of the Cartesian product of the input blocks) that satisfies the conditions. This is done using the concept of an odometer (or ranged permutations). If we need to loop over a single series s, we will do it length? s times. When we need to make a Cartesian product with values of all supplied series, we’ll need to loop the product of lengths of all the series times (nested loops). For example, if want to make the Cartesian product of the following three series: [1 2], [3 4 5] and [6 7 8 9], we’ll end up with 2 * 3 * 4 or 24 iterations. This give us the idea for a “lazy” way to generate the results.

We will initialize a counter to 0 and will be increasing its value at each function call, until we finally reach the product of all lengths. In order to map the counter (an integer!) to a block of integers, representing the indices of interest at each iteration, we need to convert the counter to a mixed base number system. The bases (radices) will be the lengths of the series. Here’s an example of the helper function mixed-base:

Please note that a general-use function converting a number to a mixed base system will return numbers from 0 to respective lengths – 1 – I have corrected the result to be useful for Red’s 1-based indexing. As you can check, these are all the combinations for indexing into the above mentioned three series: [1 2], [3 4 5] and [6 7 8 9].

So, when called with counter 1, the gen-list function will convert it to a block of integers depending on the given base – [2 3 4] in our case – or [1 1 1]. Next call will increase the counter to 2 and the result will be [1 1 2] – the last index is increased first, simulating a deepest nesting. Thus, increasing the counter, we will eventually reach 24 (this is 2 * 3 * 4) which maps to [2 3 4]. Each one of these blocks with indices is used to extract a value from the corresponding series and feed the set of values to the function specified in the spec block.