! bool.ax.txt - Boolean functions that use or yield `t/`f (true/false) values
! We also include predicates involving `nil.
! uses form.ax, ho.ax, bit.ax , char.ax
! We adopt the convention of having '?' at the end of a Boolean function name.
!/
 t, f, tf - true/false representation values (hidden in this file)
 tfset - the set of true/false values
 tfseq - a sequence of true/false values
 t/f_sel - select from two values based on t/f index
 tf_fn - combine complementary relations to yield a true/false function
 and? - conjuction of t/f values
 or? - disjuction of t/f values
 not? - map `t/`f to `f/`t
 (not? <tffn>) - complement of Boolean function
 in? - test if elem in a sequence or not (given bit-distinguishability)
 =l?, <l?, <=l? - sequence length boolean fns
 /=l?, /<l?, /<=l? - more seq length boolean fns
 =set? - test if two sequence sets are equal (given bit-distinguishability)

 map/nil - map unary function to each element of a seq to get seq of results
 dig? - test if char is a digit
 ltr? - test if char is a letter
 consec? - test if consecutive values of specified type exist in sequence
 ~boolfn? - complement of a boolean function
!\
----+----|----+----|----+----|----+----|----+----|----+----|----+----|----+----8

! t, f, tf - true/false representation values (hidden in this file!)
! (analogous to bit0, bit1, bits preds - should we just use these for t/f??)

  (t `t).
  (f `f).
    ! - alternative representations:
    !   `true, `false     - longer names
    !   `1, `0            - just use bits for true/false
    !    t, f,  true, false  - ordinary symbols
    
  (tf %t %f)< (t %t), (f %f).

! tfset - the set of true/false values

  (tfset %tf)< (one_valid (t %tf) (f %tf)).

! tfseq - a sequence of true/false values

  (def tfseq (* tfset)).

! tf_sel - select from two values based on t/f index

  (tf_sel (%tval %fval) %t %tval)< (t %t).
  (tf_sel (%tval %fval) %f %fval)< (f %f).

! tf_fn - combine complementary relations to yield a true/false function
! - a higher-order form - belongs in ho.ax??

  ((tf_fn %trel %frel) $targs %t)<
    (%trel $targs),       ! "true" rel is valid for "true" args
    (t %t).
  ((tf_fn %trel %frel) $fargs %f)<
    (%frel $fargs),      ! "false" rel is valid for "false" args
    (f %f).

  ! - It would be an error if (_trel _args_) and (_frel _args_) are ever valid
  !   for the same arguments.
  ! - Ideally, we want _trel and _frel combined to be a total function over
  !   some argument string domain.

! and? - conjuction of (zero-or-more) t/f values

  (and? $tfargs %t)<
    (t %t),
    (copies %t ($tfargs)).   ! all args are true
  (and? $tfargs %f)<
    (f %f),
    (tfseq ($tfargs)),
    (in %f ($tfargs)).     ! at least one arg is false
  ! - can't use in? here since `t/`f are not bit-distinguishable

! *** Have 2-arg and?, sequence and*? and multiarg and_?, like cat!
!     (same for or?)
    
! or? - disjunction of (zero-or-more) t/f values

  (or? $tfargs %f)<
    (f %f),
    (copies %f ($tfargs)).    ! all args are false
  (or? $tfargs %t)<
    (t %t),
    (tfseq ($tfargs)),
    (in %t ($tfargs)).      ! at least one arg is true

! not? - map true/false to false/true

  (valid (not? %t %f)
         (not? %f %t))< (tf %t %f).

! (not? _tffn) - complement of Boolean function

  ((not? %tf_fn?) $args %ft)<
    (%tf_fn? $args %tf),
    (not? %tf %ft).

! in? - test if elem in a sequence or not (given bit-distinguishability)

  (def in? (tf_fn in /in)).
  
  ! - Note that we adopt the convention that a name ending in ? denotes a
  !   function that yields a boolean result.

! =l?, <l?, <=l? - seq length boolean fns

  (def =l? (tf_fn =l /=l)).
  (def <l? (tf_fn <l >=l)).
  (def <=l? (tf_fn <=l >l)).

! /=l?, /<l?, /<=l? - more seq length boolean fns

  (def /=l? (not? =l?)).
  (def /<l? (not? <l?)).
  (def /<=l? (not? <=l?)).

! =set? - return t/f if two sequence sets are equal
! (order and duplicates do not matter - requires bit distinguishability)

  (=set? %seq1 %seq2 %t)<
    (t %t),
    (all_in %seq1 %seq2),
    (all_in %seq2 %seq1).
  ! - or use permutation if no duplicates!

  (=set? %set1 %seq2 %f)<
    (f %f),
    (one_valid (some_/in %set1 %set2)
               (some_/in %set2 %set1)).


! map/nil - map a unary function to each elem of a seq to get seq of results
! - A "defined" result for function application will be a sequence value,
!   else the result must be the `nil value, in which case the function
!   result is omitted from the result sequence.

  (map/nil %f () ()).
  (map/nil %f (% $) (%r $r))<
    (%f % %r),
    (seq %r),              ! func has defined value, so we include its result
    (map/nil %fn ($) ($r)).
  (map/nil %f (% $) ($r))<
    (%f % `nil),           ! func value undefined, so result is omitted
    (map/nil %f ($) ($r)).

  ! example would be good here - div by 0, avg of nat seqs, including empty seq


! dig? - test if char is a digit

  (def dig? (dig /dig)

! ltr? - test if char is a letter

  (def ltr? (ltr /ltr)

! consec? - adjacent values of same type exist in sequence

  (consec? %type? %seq %t)<     ! consecutive type values exist
    (t %t),
    ((* %type?) %seq %tfseq),    ! test type of all seq values
    (substr (`t `t) %tfseq).     ! two adjacent 'true' values
  (consec? %type? %seq %f)<     ! no consecutive type values exist
    (tf %t %f),
    ((* %type?) %seq %tfseq),
    (no_consec %t %f %tfseq).

! ~boolfn? - complement of a boolean function

  ((%sym` ('~' $bfname '?')) $args %tf)<
    ((%sym` ($bfname '?')) $args %ft),
    (not? %ft %tf).