List structure in RDF

        list --first--> a
        list --rest--> gen1
        gen1 --first--> b
        gen1 --rest--> gen2
        gen2 --first--> c
        gen2 --rest--> empty

Properties

@@List partitioned by first, rest (in the larch sense)

• first: List -> anything

  first(l, x) = x is the first item in l

• rest: List -> List

  rest(l1, l2) = l2 is the rest of l1, after the first item.

Utilities

append([], Z, Z).
append([A|B], Z, [A|Z2]) :- append(B, Z, Z2).
reverse([], []).
reverse([A|B], Z) :- reverse(B, Brev), append(Brev, [A], Z).

-- js-prolog page

function symbols (i.e. [] notation) have to be manually "unwound", I guess

@@hhmm... how to handle n-ary relations? ALL paper says to treat r(x, y, z) as r(x, (y, z))... I think. @@hmm... how about supporting the r(x, y, z) syntax from the XSLT transformation?

@@specify converts ... in the larch sense. see also: faq entry

• in: Resource -> List

  in(x, y) = x is in y.

  in(x, l)

  if

  • first(l, x).

  in(x, l1)

  if

  • rest(l1, l2)
  • in(x, l2).

• second: List -> anything

  second(l, x) = x is the second item in l.

  second(l, x)

  if

  • type(l, List)
  • rest(l, l2)
  • first(l2, x).

• append: List -> List

  append(empty, Z--Z)

  • first(Z--Z, Z)
  • second(Z--Z, Z).

  append(A-B, Z--A-Z2)

  if

  • append(B, Z--Z2)
  • first(A-B, A)
  • rest(A-B, B)
  • first(Z--A-Z2, Z)
  • second(Z--A-Z2, A-Z2)
  • first(Z--Z2, Z)
  • second(Z--Z2, Z2)
  • first(A-Z2, A)
  • rest(A-Z2, Z2).

• reverse: List -> List

  reverse(empty, empty).

  reverse(AB, Z)

  if

  • reverse(B, Brev)
  • append(Brev, Alist--Z)
  • first(Alist--Z, Alist)
  • second(Alist--Z, Z)
  • first(Alist, A)
  • rest(Alist, empty).