// <code><pre>
// kids -- from last time
kids( n, [] ) => [];
kids( n, [[a,b]|R] ) => n == a ? [b|kids(n,R)] : kids(n,R);

// alternative version 
// using the "weirdo analysis" or the 
// "use-it-or-lost-it" technique...
kids2( a, [] ) => []; 
kids2( a, [[c,d]|R] ) =>  useit = (c==a ? [d] : []),
                         loseit = kids2( a, R ),
                         append( useit, loseit );


test( kids( "a", [["a", "b"], ["a","c"], ["b","c"], ["d","a"]]), ["b", "c"] );
test( kids2( "a", [["a", "b"], ["a","c"], ["b","c"], ["d","a"]]), ["b", "c"] );


// sublists from class -- another "use-it-or-lose-it" example
sublists( [] ) => [ [] ];
sublists( [f|R] ) => loseit = sublists(R),
                      useit = map( (L)=>[f|L],  loseit ),
                     append( loseit, useit );

test( sort( sublists( [1,2] ) ),   [ [], [1], [1,2], [2] ] );

// use-it-or-lose-it reachable:
reach( a, a, G ) => 1;  // the order of these two base cases matters!
reach( a, b, [] ) => 0;
reach( a, b, [[c,d]|R] ) => loseit = reach( a, b, R ),
                            u1 = reach( a, c, R ),
                            u2 = reach( d, b, R ),
                            useit = u1 && u2,
                            useit || loseit; // hooray!

test( reach( "a", "b", [ ["c","d"], ["a","z"], ["d","b"], ["z","c"] ]),  1 );
test( reach( "b", "a", [ ["c","d"], ["a","z"], ["d","b"], ["z","c"] ]),  0 );

// merge example from class
merge( [], M ) => M;
merge( L, [] ) => L;
merge( [f|R], [e|S] ) => f <= e ? [f|merge(R,[e|S])]
                                : [e|merge([f|R],S)];



test( merge( [0,3,4,5,8,10], [0,1,2,4,6,7,9,11,11,15,42] ),
      [0,0,1,2,3,4,4,5,6,7,8,9,10,11,11,15,42] );


// diff example from class
diff( [], M ) => [];
diff( L, [] ) => L;
diff( [f|R], [e|S] ) =>  f == e ? diff(R,S) 
                       : f <  e ? [f|diff(R,[e|S])]
                       :          diff([f|R],S);


test( diff( [0,3,4,5,8,10], [0,1,2,4,6,7,9,11,11,15,42] ),  [3,5,8,10] );


// </pre></code>