Module list

We need some kind of fold-like procedure for generalising operations on arbitrarily nested iterables. We can't use a normal fold because Python doesn't have the equivalent of cons, etc; this tries to be more Pythonic (see comments later).

We divide everything into iterables ("lists") and atomic values ("items"). per_list is called with a generator over the (transformed) top-most list, in order. Items (ie atomic values) in that list, when requested from the generator, will be processed by per_item; iterables will be processed by a separate call to per_list (ie recursively).

So this is more like a recursive map than a fold, but with Python's mutable state and lack of typing it appears to be equally powerful. Note that per_list is passed the previous type, which can be used for dispatching operations.

Generate a tree using the same "trick" as GraphStr.

The initial fold returns a function (str, str) -> list(str) at each level.

count_sexpr

Count the number of value nodes in an AST.

(Note that size(List) gives the number of entries in that list, counting each sublist as "1", while this descends embedded lists, counting their non-iterable contents.

Value:

sexpr_fold(per_list= lambda type_, items: sum(items), per_item= lambda item: 1)

join

Flatten a list of lists by one level, so [[1],[2, [3]]] becomes [1,2,[3]].

Note: this will only work correctly if all entries are lists.

Value:

lambda items:

sexpr_flatten

Value:

sexpr_fold(per_list= lambda type_, items: join(items), per_item= lambd a item: [item])

sexpr_to_str

Value:

sexpr_fold(per_list= lambda type_, items: fmt(_fmt.get(type_, '{0}([{1 }])'), type_.__name__, ','.join(items)), per_item= lambda item: repr(i tem))