As for the issue of one-many and many-many, I guess I would suggest that in a one-to-many situation I would try and store the "many" as a child field in the "one", not use two separate tables if you can get away with it (one of the advantages of a non-RDBMS is that this design is possible)

As for many-many, I would probably have two tables, then have an extra table that just maps keys to keys for the two tables. Basically, just like an RDBMS association table. (or maybe even a bidirectional table, if you need to go "both ways")

If you want to know the "official" way to store data in different relationships in a simple, purely functional, memory resident database, I'd look at HApps-ixset. This is philisophically closely aligned to what you'd need in arc and is designed by some super smart guys. Unfortunately, their documentation is wanting or I'd point you to a good link that describes how to use it.

  lim{x -> 0}(x/x) = 1
  lim{x -> 0}(x/0) = NaN
  lim{x -> 0}(0/x) = 0

The basic way I'd think of it is that LISP lets you do clever things by keeping the core design of the structures inside of the compiler/interpreter as simple/primitive as possible.

Smalltalk lets you do clever things by having the run time system "take care of the hard stuff for you."

"Strings" are used for communication with a human- Human readable text is an important tool that software uses for interacting with a user.

Inside the actual logic of a program it really has no useful role. It is unfortunate that a byte hold a text character reasonably efficiently, so almost all software uses strings as primary data structures, even though they don't belong in the body of a program.

In my view, strings should only be used in two places in any application: 1. Acquiring raw data from the user to parse into more meaningful internal data structures. 2. In the final step when rendering text for the human to read, generated from internal data structures.

I think it would be interesting (though perhaps not practical) if arc had only two commands with string support (string-to-sexp fmt str) and (sexp-to-string fmt sexp)... In this case, the 'fmt parameter would be some kind of definition of the string syntax, something like a BNF or RegEx description. The only other things you'd be able to do is somehow acquire it from the user and somehow display it to the user. Any internal manipulation of strings would be impossible and unnecessary.

Strings have no place in the core logic of a program. It is only because of inertia that we have this remnant from the early terminal days.

Besides the early flurry of articles at its release it hasn't really gotten much notice. But that's OK- the goal of this language is to create something with a long time horizon in mind. Nobody, not even pg, would argue that arc, in its current form, is much of a technological breakthrough yet. Its contributions are more conceptual at this point. I think, though, for a certain style of programmer (such as myself and the few others frequenting this forum :-) it has a lot to offer, even in its current, incomplete, form.

From the manual http://www.basis.uklinux.net/ursala/manual.pdf

  $ fun --main="˜&nSiiDPSLrlXS" --decompile
  main = compose(
    map field((0,&),(&,0)),
    compose(
      reduce(cat,0),
      map compose(
        distribute,
        compose(field(&,&),map field(&,0)))))

  #import std
  #import nat
  
  #comment -[
  solves the general case of the 8 queens problem;
  invoke as queens -n, where n is a number > 3]-
  
  #executable <'par',''>
  #optimize+
  
  queens =
  
  %np+~command.options.&h.keyword.&iNC; -+
     ~&iNC+ file$[contents: --<''>+ %nLP*=; * '<'%='[ '+          ','%=', '+ '>'%=' ]']+ ~&rSSs+ nleq-<&l*rFlhthPXPSPS,
   ~&i&& ~&lNrNCXX; ~&rr->rl %tLnLtXLLWXMk+ ^/~&l ~&lrrhrSiF4E?/~&rrlPlCrtPX ~&r; ^|/~& ^|T\~& -+
      -<&l^|*DlrTS/~& ~&iiDlSzyCK9hlPNNXXtCS,
      ^jrX/~& ~&rZK20lrpblPOlrEkPK13lhPK2; ~&i&& nleq$-&lh+-,
   ^/~&NNXS+iota -<&l+ ~&plll2llr2lrPrNCCCCNXS*=irSxPSp+   ^H/block iota; *iiK0 ^/~& sum+-

(5 x) ==> (is 5 x)

...and also:

('foo x) ==> (is 'foo x)

  ((table) (table))

However, I think this could be a good candidate for ssyntax :

  foo?x ==> (is foo x)

  ('foo) x) == ((quote foo) x)