There is no notion of definition by example in most grammars for any FOL, and very little other syntactic sugar. You have to look at your data structures in purely relational terms.
Exists x: Person(x) & Name(x, 'bart') & Age(x, 12)
(Officially Exists is the inverted E, each predicate we have named has to be a subscripted phi and all constants are subscripted a's with a separate axiom stating the assigned value, and all variables are subscripted x's. But I am just not typing that.)
If this is the only sort of list relation you have in mind, then you don't need the lists because they are just a mechanism providing uniformity, and do not affect the content.
In theory there is not anything that rules out lists or even lists of lists. You can introduce a schema, like the one for induction.
The axioms of an FOL do not have to be finite, just recursively enumerable. So you can define a function in infinitely many steps, as long as the steps are stereotyped enough to be emitted by some template. What constitutes a template varies between versions of FOL. But all of them admit some mechanism allowing arbitrary repetition, usually via indexing, because induction is crucial to all arithmetic and stating the induction axioms generally requires a polymorphic function that takes every different number of arguments.
So this kind of mechanism is not outside the spirit of FOL. But it might be impossible to express in any way that is not ambiguous or hopelessly confusing unless you explicitly write the recursive function that enumerates your axioms. All of these systems generally contain just one scheme. Some generalizations to real closed fields with convergence, or other advanced mathematics, may have two or three schemata at the outside. So the expressive power is severely limited to just handle those few cases. For instance the definition of convergence, or lexicographical ordering.
Using the language that Schoenfield introduces to express the Peano axioms in his version of Goedel's theorem, if you really need to define a function that takes two lists, you have to pass the lists 'zipped' and do something like:
Less(x, y, x, y ... x[n], y[n]) <-> x < y & x < y ... x[n] < y[n]
(Again x and y are syntactic sugar, officially there is only x, so these are x[0, 1]...x[0, n] and x[1, 1]...x[1, n].)
If you want to handle two different length lists you need to pad them out with some 'nil' marker, etc.
A precondition that asserts a list of lists is lexicographically ordered already becomes insane:
Sorted(x[1, 1], x[1, 2], x[1, 3]... x[2, 1], x[2, 2], x[2, 3]... x[n, m]) <-> Less(x[1, 1], x[2, 1]) & Less(x[1, 2], x[2, 2]) & ... Less(x[1, n], x[2,n]) & Less(x[2, 1], x[3, 1]) & Less(x[2, 2], x[3, 2]) & ... Less(x[2, n], x[3,n]) ... ... Less(x[m - 1, 1], x[m, 1]) & Less(x[m-1, 2], x[m, 2]) & ... Less(x[m - 1, n], x[m,n])
So it is hardly worthwhile. FOL languages are not meant to be used to say anything meaningful. They are meant to express a few well-rehearsed proofs about extremely simple systems or nail down some very limited axioms so that we can enumerate their models.
What is the goal of this enterprise?