#nested lists

Answer: Hey, @akwardlyuncool!

The truth is there were several small things like this that we intended to do with the post editor—but we had to move on to other priorities before we got a chance. They are still on our proverbial to-do list, we just haven’t had the time to do them. And honestly, it’s difficult for us to justify doing them since we know they were used by a very, very, very tiny number of people.

Inspired by VS Code and IntelliJ IDEs. Now in your outlines.

If you've used Sticky Scroll in VS Code, or Sticky Lines in IntelliJ, you already know how much they help. You’re deep in a file, and the code editor shows the function or class name pinned at the top — so you always know where you are.

So we thought, why not? 🤓

Introducing Sticky Scrolling in Checkvist

Sticky Scroll in Checkvist consists of two options, both turned on by default:

✅ Sticky Header

The list title and navigation/search bar stay pinned to the top of the screen as you scroll.

✅ Sticky Parent

When a task has children, the parent stays in view while you scroll through its sub-tasks. This makes it easier to navigate deeply nested lists, like a changelog, for example 👇

Both options are enabled by default - but you can configure them as you like.

We ourselves have different setups: Kir prefers sticking both header and parent. Sasha keeps just the sticky parent (probably because she's on a smaller laptop).

You can choose what works for you on your profile. Let us know what you think — and how we can make it better.

👉 Try Sticky Scroll in Checkvist

The class started learning recursion this week ( and actually a little bit last week) where we defined what the concept is and had a simple example of its use. Recursion is a logical concept in which the function is defining something in terms of itself. A weird example that helped me understand it is Matryoshka dolls. each doll identical to the other is inside the other. This might be a limited example but it did help me have an initial idea of where the recursion concept was heading. 

Professor Heap introduced the nested list example, where we had to implement a function that calculated the depth of a certain nested list. Depth in a list represents how many nested lists there are in other lists. For example, [1, 2, 3] is a flat list or a list of depth 1. But [1, [2, 3]] is a list if depth 2. After understanding this, writing the API wasn’t particularly challenging and I thought implementing it wouldn’t be impossible but it would be tedious for sure. However, unsurprisingly, the professor used recursion to implement this method which was so efficient but at the same time I had a lot of trouble understanding it at a first glance. 

First, we had to think of an edge case where the object being used in the function isn’t necessarily an instance of a list and in which case our function (which counts nested lists) would return zero. From there, we also account for the case where we have an empty list [] and in that case even though the list doesn’t necessarily contain other elements it is still of type list and therefore it is of depth 1. Finally, we have to account for the most common case, a nested list. Once We get to that line, we are sure that object is a list of at least depth 1 and therefore before thinking about anything we should know that our result should add 1 to get a correct final result. The challenging part is to implement a function that somehow iterates over items in the object and counts if the items are lists, except we already have.

By implementing a list comprehension that iterates over the list using the function itself, we realize (mostly by tracing) that this method which returns the maximum of the output of the list comprehension + 1 works :

Python – sort a list of nested lists

I have input consisting of a list of nested lists like this:

l = [[[[[39]]]], [1, 2, 3], [4, [5, 3], 1], [[[[8, 9], 10], 11], 12]]

I want to sort this list based on the sum of all the numbers in the nested lists… so, the values I want to sort by of l would look like this:

[39, 6, 13, 50]

Then I want to sort based on these. So the output should be:

[[1, 2, 3], [4, [5, 3], 1], [[[[39]]]],…