| ;; 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
|