;; This buffer is for text that is not saved, and for Lisp evaluation.
;; To create a file, visit it with C-x C-f and enter text in its buffer.

(Dedun gem-tree-create-corpus-from-entry)
(Defun gem-tree-couple-corpus-with-context)
(Defun gem-tree-decode-possibie-decoded-entries-ffom-context)
(defun gem-tree-assign-score-of-probability-of-to-decoded-meanings)
(Defun act-on-entry)

(defun gem-tree-of-word-at-point-compounding)
(defun gem-tree-of-word-at-point (&optional ))
  "Show as convenient popup with key to drill down or more advanced"


(defvar gem-tree-popup-mode-map
  (let ((map (make-keymap)))

    (define-key map "\C-m" 'hexl-self-insert-command)
    (define-key map [left] 'gem-tree-previous-page)
    (define-key map [right] 'gem-tree-next-page)
    (define-key map [up] 'gem-tree-up-recurse)
    (define-key map [down] 'gem-tree-down-recurse)
    (define-key map [M-left] 'gem-tree-previous-system)
    (define-key map [C-M-left] 'gem-tree-redo-with-previous-recursive-fn)
    (define-key map [C-M-right] 'gem-tree-redo-with-next-recursive-fn)
    (define-key map [?\e left] 'hexl-backward-short)
    (define-key map [M-right] 'hexl-forward-short)
    
    (define-key map [remap self-insert-command] 'hexl-self-insert-command)

(define-minor-mode 

(defun transforming-function-1)

(gem-tree-of-entry "a"
		   'asc
		   t
		   10
		   (transforming-function-1
		    transforming-function-2
		    ...
		    transforming-function-n)
		   (pre-filter-transform-function-1
		    pre-filter-transform-function-2
		    ...
		    pre-filter-transform-function-n)
		   ;; etc as the -fn arguments can be a single function
		   ;; of multiple derivations or a list of one-function-derivation
		   ;;
		   ;; can create per-use language using
		   
		   ;; - list of lambdas then extract into own function
		   ;; - or lambda with multiple tests
		   
		   ;; matches specific phrase?
		   ((lambda (e) ; matches phrase?
		      (or (string-match-p "some-phrase" e)  ; matches phrase?
			  (apply is-numerically-equal-to 8) ; 
			  (is-phonetically-similar-to X)
			  (if-numerically-equal-to-with-extra #'extra-function number)
		    (kokfiafIFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
		  
(defun gem-tree-of-entry (entry &optional
				sort
				system
				first-n				
				;; transform
				step-transform-fn ;; -=-=-=-=- transform between all passes
				;; filter
				pre-filter-transform-fn  ;; < transform before filter
			        single-filter-fn         ;; = test aginst individual
 				all-filter-fn            ;; = test against all
				post-filter-transform-fn ;; > transform after filter
				;; go deeper and call again
				word-recursively
				system-recursively
				fn-recursively
				;; stop: stop when this condition found against entry/entries
				stop-fn
				accul-stop-fn)
  "Gem tree of entry ENTRY.

Entry can be a word or a multi-word string.

Show only first FIRST-N entries with equivalent value.

To entries use either 'asc', 'desc', or a sort function
SORTFN.

Select the systems SYSTEMS, nil, 't' or a list of systems.

To filter the results either as a whole or individually specify a
per-entry-basis SINGLE-FILTER-FN or per-entry-collection-basis
ALL-FILTER-FN.  It will expect a list of entries as input. For example
to match with/against a list of regexps.

To go deeper specify WORD-RECURSIVELY which calls this function
recursively against a. each individual word of all entries produced so
far or b. against each SYSTEM's value for all entries produced so far.
For both of these 't' to go indefinitely, STOP-FN to go until STOP-FN
returns 't' for each round of produced entries or successively
accumulated entries using ACCUM-STOP-FN.
FN-RECURSIVELY to call this function to transform the resulting entries and
then run this function against recursively against each output entry.")

304