how to merge a list of pins back into bus<0:7> data<8:15>

I remember vaguely to have seen something like this either in the forum or in support but was not able to find it again. Maybe somebody else has a better memory.
However, I have an older piece of code that might almost fit your requirements, although prob. not very efficient. I've not used it in applications so it may not cover corner cases (was just a proof-of-concept). So, handle with care. 

One thing is that the bus order is not determined from the input sequence. Although it accepts the bits ascending/descending/mixed, the output is always MSB-first. If you need it the other way, change the "base binx ainx" arguments to "base ainx binx", or extend it to also remember the order of the bits (would go into the 'merge' part).

Regards,

; unroll list of bus and bit names
procedure(unroll_busNameList(nameList)
    let( (res tmp new n a b base ainx binx fnc)
        fnc = lambda( ()
            when( base
                new = if(binx==ainx
                    sprintf(nil "%s<%L>"    base ainx)
                    sprintf(nil "%s<%L:%L>" base binx ainx)
                )
                res = tconc(res new)
                base=nil
            )
        )
        foreach(name nameList
            tmp=parseString(name "<:>")
            n = car(tmp)
            if( cadr(tmp) then
                ; name is bus or single bit
                a = atoi(cadr(tmp))
                b = if(caddr(tmp) atoi(caddr(tmp)) a)
                cond(
                    ( !numberp(a) || !numberp(b)
                        error("invalid indices in %L\n" name)
                    )
                    ; merge
                    ( base==n && binx+1==a a=ainx)
                    ( base==n && ainx-1==b b=binx)
                    ; output cache
                    ( t funcall(fnc))
                ); cond
                base = n
                ainx = a
                binx = b
            else
                ; name is scalar
                ; output cache
                funcall(fnc)
                res = tconc(res n)
            )
        )
        ; output remaining cache
        funcall(fnc)
        car(res)
    ); let
)

Here's some code I've posted before which does this. This does preserve the order...

Andrew