You can easily make lists of lists

list1 <- list(a = 2, b = 3)
list2 <- list(c = "a", d = "b")
mylist <- list(list1, list2)

mylist is now a list that contains two lists. To access list1 you can use mylist[[1]]. If you want to be able to something like mylist$list1 then you need to do somethingl like

mylist <- list(list1 = list1, list2 = list2)
# Now you can do the following
mylist$list1

Edit: To reply to your edit. Just use double bracket indexing

a <- list_all[[1]]
a[[1]]
#[1] 1
a[[2]]
#[1] 2

Altough your example isn't reproducible, I get a list of lists with the following similar code:

potential_dups <- rep(list(list()), 10)
nearest10 <- matrix(rnorm(100), nrow=10)
for (i in 1:10) {
  for (j in 1:10) {
    if (nearest10[i, j] < 0.35 & nearest10[i, j] > 0) {
      potential_dups[[i]] <- append(potential_dups[[i]], nearest10[i, j])
    }
  } 
}  

To remove empty lists you can do this:

potential_dups[sapply(potential_dups, function(x) length(x) > 0)]

Actually you are already close to your desired output, but you may need another list() within append, e.g.,

newl <- list()
newl <- append(newl, list(list(a = 1, b = "x")))
newl <- append(newl, list(list(a = 15, b = "y")))
newl <- append(newl, list(list(a = 10, b = "z")))

such that

> newl
[[1]]
[[1]]b
[1] "x"


[[2]]
[[2]]b
[1] "y"


[[3]]
[[3]]b
[1] "z"

If you want to sort by $a, you can try

> newl[order(sapply(newl, `[[`, "a"))]
[[1]]
[[1]]b
[1] "x"


[[2]]
[[2]]b
[1] "z"


[[3]]
[[3]]b
[1] "y"

A short version:

 sapply(GroupedList, nrow)

Could it be this, what you want to have:

# Initial list:
myList <- list()

# Now the new experiments
for(i in 1:3){
  myList[[length(myList)+1]] <- list(sample(1:3))
}

myList

The coords object seems to be a list. To convert it to a matrix with 2 columns, we can rbind the list elements.

m1 <- do.call(rbind, coords)

In order to solve this elegantly you need to understand that you can use ['…'] instead of $… to access list elements (but you will get a list back instead of an individual element).

So if you want to get the elements likelihood and fixef, you can write:

modelset[[1]][c('likelihood', 'fixef')]

Now you want to do that for each element in modelset. That’s what lapply does:

lapply(modelset, function (x) x[c('likelihood', 'fixef')])

This works, but it’s not very R-like.

You see, in R, almost everything is a function. […] is calling a function named [ (but since [ is a special symbol for R, in needs to be quoted in backticks: `[`). So you can instead write this:

lapply(modelset, function (x) `[`(x, c('likelihood', 'fixef')))

Wow, that’s not very readable at all. However, we can now remove the wrapping anonymous function (x), since inside we’re just calling another function, and move the extra arguments to the last parameter of lapply:

lapply(modelset, `[`, c('likelihood', 'fixef'))

This works and is elegant R code.

Let’s step back and re-examine what we did here. In effect, we had an expression which looked like this:

lapply(some_list, function (x) f(x, y))

And this call can instead be written as

lapply(some_list, f, y)

We did exactly that, with somelist = modelset, f = `[` and y = c('likelihood', 'fixef').

Try this:

list.of.lists[order(sapply(list.of.lists,'[[',1))]

Here is an approach using rlist and purr

do.call(rlist::list.zip, out) %>%
 purrr::map(~ do.call(rbind, .))

Or, with even more purrr:

library(purrr)

out %>%
  do.call(rlist::list.zip, .) %>%
  map(~ reduce(., rbind))

Using the data that you provided, you can make a blank plot with sufficient range to include all of the lines, then use lines to plot each. I am coloring each line differently to keep them separated.

xmax = max(unlist(lapply(balance, length)))
ymin = min(unlist(balance))
ymax = max(unlist(balance))

plot(NULL, xlim=c(0,xmax), ylim=c(ymin, ymax), ylab="")
for(i in seq_along(balance)) {
    lines(balance[[i]], col=i) }

If you really want to do this, then, because the elements of the lists in each element of the array do not have names, you can't index by a character vector. In your example, there is no x[1][[ "a" ]]:

> x[1][[ "a" ]]
NULL

If there are no names then you need to index by a numeric:

> x[1][[ 1 ]] <- 1
[1] 1

It would seem more logical to have a list though than an array:

> y <- vector(mode = "list", length = 10)
> y
[[1]]
NULL

[[2]]
NULL

[[3]]
NULL

[[4]]
NULL

[[5]]
NULL
....

I have found another way which avoids the problem mentioned above, namely that combine has to create a new list first and later only append lists. Also, the real function I am using actually returns a list of lists, so the following proved useful:

combine_custom <- function(list1, list2) {
     if (plotrix::listDepth(list1$l) > plotrix::listDepth(list2$l)) {
        ls  <- c(list1$l, list(list2$l))
    } else {
        ls <- c(list(list1$l), list(list2$l))
     }
     ns <- c(list1$n, list2$n)
     return(list(l = ls, n = ns))
}

This is not perfect if the function can return lists of varying nesting depths, but it works in my case.

In R, indexing starts from 1 and not 0 - difference between Python and R. So, if we change it to 1 and 2, it works. In addition, 1:length may be replaced with less buggy seq_along

for( j in seq_along(mylist)){
    print(j)
    list1 = mylist[[j]]
    print(list1)    
    a=list1[[1]]
    b=list1[[2]]
    # usage of a and b
}
[1] 1
[[1]]
[1] 10

[[2]]
[1] 20

[1] 2
[[1]]
[1] 30

[[2]]
[1] 40

NOTE: list1, a, b are objects created within the loop and this gets updated in each iteration. It is not clear about the final outcome

Try

lapply(z, function(x) as.numeric(unlist(x)))

## [[1]]
## [1] 1 2 5 3 4 4 7
##       
## [[2]]
## [1] 1 2 3 4

We can incorporate the clean-up of inner lists into your function:

removeListElem <- function(inlist,elem_remove){
  outlist = lapply(inlist,setdiff,elem_remove)
  outlist[lengths(outlist) > 0]
}

This takes care of the integer(0)s, but still gives an empty list in the result:

result = lapply(mylist,function(x) removeListElem(x,c(4,5,19,20,23,24)))
result
# [[1]]
# [[1]]$`1`
# [1] 2 3
# 
# [[1]]$`3`
# [1] 6 7
# 
# [[1]]$`4`
# [1]  8  9 10
# 
# 
# [[2]]
# [[2]]$`1`
# [1] 11 12
# 
# [[2]]$`2`
# [1] 13 14
# 
# [[2]]$`3`
# [1] 15 16
# 
# [[2]]$`4`
# [1] 17 18
# 
# [[2]]$`6`
# [1] 21 22
# 
# 
# [[3]]
# named list()

So we can clean up the result in a similar way:

result[lengths(result) > 0]
# [[1]]
# [[1]]$`1`
# [1] 2 3
# 
# [[1]]$`3`
# [1] 6 7
# 
# [[1]]$`4`
# [1]  8  9 10
# 
# 
# [[2]]
# [[2]]$`1`
# [1] 11 12
# 
# [[2]]$`2`
# [1] 13 14
# 
# [[2]]$`3`
# [1] 15 16
# 
# [[2]]$`4`
# [1] 17 18
# 
# [[2]]$`6`
# [1] 21 22

This uses a nested lapply, just like your attempt. We can, of course, package it all into a function:

removeListElemComplete = function(inlist, elem_remove) {
  outlist = lapply(inlist, removeListElem, elem_remove = elem_remove)
  outlist[lengths(outlist) > 0]
}

removeListElemComplete(mylist, c(4,5,19,20,23,24))
# [[1]]
# [[1]]$`1`
# [1] 2 3
# 
# [[1]]$`3`
# [1] 6 7
# 
# [[1]]$`4`
# [1]  8  9 10
# 
# 
# [[2]]
# [[2]]$`1`
# [1] 11 12
# 
# [[2]]$`2`
# [1] 13 14
# 
# [[2]]$`3`
# [1] 15 16
# 
# [[2]]$`4`
# [1] 17 18
# 
# [[2]]$`6`
# [1] 21 22

We can loop through the list of list with a nested lapply/sapply

 lapply(data, sapply, mean)

It is otherwise written as

 lapply(data, function(x) sapply(x, mean))

Or if you need the output with the list structure, a nested lapply can be used

 lapply(data, lapply, mean)

Or with rapply, we can use the argument how to get what kind of output we want.

  rapply(data, mean, how='list')

If we are using a for loop, we may need to create an object to store the results.

  res <- vector('list', length(data))
  for(i in seq_along(data)){
    for(j in seq_along(data[[i]])){
      res[[i]][[j]] <- mean(data[[i]][[j]])
    }
   }

I think you could get what you want by giving

str(l1)