Well done! Thank you. Now I can move forward using a more robust dataset to rework and easily add to; finish a long term project started in 2009. Manually reworking dataset with my fingers was not something I wanted to endure (am disabled). Off to test the rest of the dataset; will report later on. I can code thusly:

WLDM["Language", "Lists", "List Parts"] 

which returns the functions I want all semantically not scrolling a long list of words. If it was easy code, I would have found code already. I will learn much from your elegant code. :-) Happy dance!

Sorry, it was intented to just be applied to your data, not used as a replacement rule. But it still doesn't quite work now that I understand your data structure (I hope).

So, trying this again. The problem is that the semantics of a list changes as we traverse down the nested lists (sometimes we want to deconstruct the list into a rule, sometimes we want the list to be a rule, and sometimes we want a list to be deconstructed into an Association). I think you could do it all in one step, but I'll break it into pieces. I'll be going back to the strategy of replacing List with functions that do the work.

StringsToRule[k_String, rest__String] := Rule[k, {rest}];
StringsToRule[else___] := {else};

StringsToRule works at the lowest level, turning lists of strings into rules such that the first element is the "key" and the rest become a new list as the "value".

RulesToAssociation[k_String, rest__Rule] := Rule[k, Association[rest]];
RulesToAssociation[else___] := {else};

RulesToAssociation will be applied after StringsToRule. At that point, we should have lists that start with a string and finish with a string of Rules. The Rules can be bundled up into an Association and attached to the string "key". We could do a similar thing with Associations, but it looks like you just have one pair in the largest scope, so we can just wrap the whole thing with a single Association.

Here we go, applying the pieces in turn:

core /. List -> StringsToRule /. List -> RulesToAssociation // Association

I'll give the same caveat: I'm still making assumptions. Maybe a different version of this kind of data would be mishandled.

Attaching a notebook of sample data. Sorry for not being fully clearer about the association nesting. I assume this is how am supposed to use your new code:

AsAssociation[list_List /; FreeQ[list, List, {2}]] := list;
AsAssociation[{k_, rest_}] := <|k -> AsAssociation[{rest}]|>;
AsAssociation[stuff___] := stuff;
core /. List -> AsAssociation

When run it, It just gives me the Head of Sequence; running as AsAssociation@core, it gives my data back. Yes, recursion would be needed.

Well, I don't know how to reproduce the problem you describe. Your sample data has a stray backslash in it, so I don't know what it's actually supposed to look like. When I remove the backslash and run my AsRule function on it, I don't have any problems. Your modified AsRule function has syntax problems, specifically it's missing the pattern stuff on the left hand side. Trying to use it exactly as is doesn't work at all, so I'm assuming there is a copy-paste error there. So, the upshot is that I don't have enough information to know what is going wrong in your case.

Sidenote, some your variable names are amusing!

I'm making some assumptions:

• The structure could be more complicated than what you've shown, in particular it could be more nested
• You only want a list transformed if the first element is a string, otherwise you want to leave it as a list
• The only Association that should be generated is the outermost one

You could define something like this:

AsRule[k_String, rest__] := k -> {rest};
AsRule[stuff___] := {stuff}

Then do a replace:

data /. List -> AsRule

Then just wrap the result in Association.