;; Peter Mowry
;; All seven tested and shown to work properly
;; Extraneous NIL's removed from the set function outputs

;; (car (member (car A) B)) append (car (member (car (cdr A)) B))
;; append (car (member (car (cdr(cdr A))) B))
;; append (car (member (car (cdr(cdr(cdr A)))) B))

( defun my-intersection ( A B )
	( cond  ( ( null A ) nil )
		( ( atom A ) (car (member A B) ) )
		( t ( remit 'NIL
			( cons ( my-intersection (car A) B ) ( my-intersection (cdr A) B ) ) ) )
	)
)

;; This finds what in A is not in B
;; This is used to simplify my-union and my-dif-helper
( defun in-A-not-B ( A B )
	( cond  ( ( null A ) nil )
		( ( atom A )
			( if ( = ( length ( member A B ) ) 0 ) A nil ) )
		( t ( cons ( in-A-not-B (car A) B ) ( in-A-not-B (cdr A) B ) ) )
	)
)

;; my-remove was not originally written recursively
;; When this was fixed, it no longer successfully removed NIL's
;; The non-recursive remit is for that purpose
;; remove all elements of atom A from list B
( defun remit ( A B )
	( cond  ( ( null B ) nil )
             	( ( equal A ( car B ) ) (remit A ( cdr B ) ) )
   	        ( t ( cons ( car B ) (remit A ( cdr B ) ) ) )
	)
) 


;; If A member B then it was already added.  Else, add A
( defun my-union ( A B )
	( remit 'NIL ( append ( in-A-not-B A B ) B ) )
)



;; Similar to union, but only append if not a member
;; Uses min-A-not-B both ways (A to B and B to A) to get the cumulative difference
( defun my-difference ( A B )
	( remit 'NIL ( append ( in-A-not-B A B ) ( in-A-not-B B A ) ) )
)

( setq AisInB NIL )

;; Helper function for memberp - sets the function AisInB to T or NIL
( defun setMembp ( A B )
	( cond 	( ( atom B ) ( if ( eql A B ) ( setq AisInB T ) ) )
		( ( listp B )
			( cons ( setMembp A ( car B ) ) ( setMembp A ( cdr B ) ) ) )
		( t ( cons ( setMembp A ( car B ) ) ( setMembp A ( cdr B ) ) ) )
	)
)

;; Atom A is checked to see if it exists anywhere in list B,
;; including in sub-lists
( defun memberp ( A B )
	( cdr ( cons ( setMembp A B ) AisInB ) )
)

( defun my-remove ( A B ) 
	( cond  ( ( null B ) nil )
		( ( listp (car B) ) ( cons (my-remove A (car B) ) (my-remove A (cdr B))))
     		( ( eql A ( car B ) ) ( my-remove A ( cdr B ) ) )
  		( t ( cons ( car B ) ( my-remove A ( cdr B ) ) ) )
  	)
)

;; Fully reverses a list, including the sub-lists
( defun fullrev ( A )
	( cond  ( ( atom A ) A )
		( ( listp A )
			( append ( fullrev ( cdr A ) ) ( list ( fullrev ( car A ) ) ) ) )
		( t ( append ( fullrev ( cdr A ) ) ( list ( fullrev ( car A ) ) ) ) )
	)
)

;; List A replaces atom B in list C
;; See if a char should be spliced.  If not, put it out there
( defun sub-splice ( A B C )
	( cond  ( ( equal C nil ) nil )
	 	( ( listp ( car C ) )
		 	( cons ( sub-splice A B ( car C ) )
				( sub-splice A B ( cdr C ) ) )
		)
	 	( ( equal B ( car C ) )
	        	( cond  ( ( atom A ) ( cons A ( sub-splice A B ( cdr C ) ) ) )
	           		( t ( append A (sub-splice A B ( cdr C ) ) ) )
           		)
	 	)
         ( t ( cons ( car C ) ( sub-splice A B ( cdr C ) ) ) )
  	)
)

( defun no-nil ( A )
	( cond  ( ( null A ) 'P )
		( ( atom A ) ( ( not ( null A ) ) A ) )
		( t ( cons ( car  A ) ( no-nil ( cdr A ) ) ) )
	)
)


( defun my-remove1 ( A B ) 
	( cond  
     		( ( eql A ( car B ) ) ( my-remove A ( cdr B ) ) )
  		( t ( cons ( car B ) ( my-remove A ( cdr B ) ) ) )
  	)
)