- multidirectional    (... sometimes ...)

Prolog Signature of append/3
 Lie:
  append(+,+,-), append(-,-,+).
 Actually:
  append(-,-,-).

HW3:
 noah(-,-).
 ev(+,-).
 subst_list(+,-,+,+), subst_list(-,+,+,+).
 diff(+,-).

DEBUGGING

TROUBLE IN PROLOG

 NUMBERS:
  N is E           same as       is(N,E)
  is(-,+)

 NEGATION
  (mutual exclusion, NOT, ...)

    foo(...) :- ..., !, foo(..)....          case 1
    foo(...) :- ....                         case 2

PATTERN MATCHING

  mem(E, [E|L]).
  mem(E, [_|L]) :- mem(E, L).

  % mem(_, [])    (NOT!)

  versus:

  (define mem
    (lambda (e l)
       (and (not (null? l))
	    (or (equal? e (car l))
		(mem e (cdr l))))))

  struct foo a = {12, 13, 99};
  a.something;

  foo(struct foo a)

  foo(struct foo {a1,a2,a3})

  scheme can do "data patterns" in a forward way: pattern to composite structure
     `(a b c ,expr (d ,@fexpr) e)
  but cannot go backwards
     (let ((  var   val  )) ...)
  let VAR be pattern?
     (let ((vcar (car val))  (vcdr (cdr val))) ...)
     (let (( `(,vcar ,@vcdr) val )) ...)

  TEASE APART PROLOG'S PATTERN MATCHING


     % foo([A,B,C,D|E]) :- ...          list, length at least four

    - check that an argument matches structural criteria

     % foo([A, bbb, ccc, D | E])        list, len>=4, 2nd elt=bbb, 3rd elt=ccc

    (define foo
      (lambda (x)
         (if (and (list? x)
		  (>= (length x) 4)        ; (let ((cdrx (cdr x)))
		  (equal? (cadr x) 'bbb)   ;    (equal? (car cdrx) 'bbb) ...)
		  (equal? (caddr x) 'ccc))
	      (let ((a (car x)) (d (cadddr x)) (e (cddddr x)))
	         ...))))

         - allows modularization of different "cases" of function

    - binding of variables to hunks of a structure

    - equality testing
       - hunks of structure equal to each other
       - hunk of structure equal to hunks from elsewhere

  write a relation to test if the same element occurs twice in succession
  in a list

    twice_in_row([A,A|_]).
    twice_in_row([_|E]) :- twice_in_row(E).

SURFACE SYNTAX vs INTERNAL SYNTAX

 - accessible to programmer in sensible way
 - programmer can define new surface syntax

    eg can make     joe hasa couch     read as    has_a(joe,couch)

PROGRAMMING BY EXAMPLE (prototype?  generalized example?)

PATTERN MATCH on both INPUTS & OUPTPUTS

 relation foo(+,-) in prolog ... like function foo(x) in conventional lang
  -> use same mechanisms for "inputs" and "outputs"