atoms | free open source ui toolkit | Style Language library

Let RDKit compute 2D coordinates and use the CoordGen library.

Your copy constructors are just doing shallow copies of each field. That's fine for strings because they're immutable, and it's fine for ints because they're primitive (which means they lack identity and are immutable). In those cases, there is no important difference between shallow and deep copies. But it doesn't work in general for lists because lists can be mutable and so can their elements. So instead of just pointing at the same list, you need to make a new list and deep copy each element of the original list into the new one.

Use this helper method to make deep copies of any lists:

I think that Jest (or other test utility) cant find props.theme because theme is undefined. You have to pass theme to your component.

Unfortunately, while coping and yaking I forgot to change the recursive calls on atoms-to-q-no-null. I realized this error while preparing this question for stackoverflow.

Since I had already written some part of the question, I thought it would be better to answer it and make the effort useful for other people.

After fixing the recursive calls of the function:

Thank you, everyone. I have solved the issue. If anyone gets similar error here is the solution: In my case the error was because these three variables:

Yes in principle it is possible:

glTranslate defines a translation matrix and multiplies the current matrix with the new translation matrix. Hence all the translations are concatenated.
Use glPushMatrix/glPopMatrx to save the current matrix before specifying the translation and to restore the current matrix after drawing the atom:

In computer science terms, what you have here is what is known as a graph. Your molecules are what known as "nodes" or "vertices" and your connections between them is known as "edges". You need to find the distance between the oxygen and all other nodes. This can be done with what is called a Breadth first search (there are other methods, but i think this is the easiest one to start with)

I strongly suggest you read the wikipedia page on this, but here is a python version adapted to your data structure:

I know of atoms in Clojure, but nothing of other languages

All FP languages will most likely have a construct similar to Clojure's atom, for example Haskell has TVar, MVar, TMVar which are similar managed safe mutable containers like Atom and Ref are in Clojure. This is because state is often unavoidable, and memory is not infinite, so at some point you need mutation, but what FP languages do is isolate that mutation and manage it so you limit its impact on program complexity and safety.

Now probably what you want to hear as you're trying to keep things purely functional and I feel your question is... but aren't these mutable state containers non functional?

Well the answer is to keep to a pure FP style, you need to model things as a data-flow and pass state along. You maintain state because it's constantly passed along to the next thing running or waiting. Sometimes that's more ackward than good though, and lots of frameworks in FP languages won't do that, they'll use a managed mutable container like an atom.

So here's the gist: