alldics : { :[ 0 < # x : dicsabs x ; x , ,/ _f' x ; 0#` ]  }
alldics..h : " absolute names of all subdictionaries of tag `x "

CCON : { x @ CCONN[ x ; y ] }
CCON..h : "case sensitive CON"

CCONB : { ~ ~ #:' x _ss\: y }
CCONB..h : "case sensitive CONB . Bottom level for all `CON fns . Uses  _ss  so literals \"?[^-]\" must be escaped with [] ."

CCONN : { & CCONB[ x ; y ] }
CCONN..h : "case sensitive CONN"

CIN : { x @ CINN[ x ; y ] }
CIN..h : "Case sensitive `IN "

CINB : { ( ( # y ) #/: x ) ~\: VEC y }
CINB..h : "Case sensitive , Bool of x matching y up to length of y"

CINN : { & CINB[ x ; y ] }
CINN..h : "Case sens , indices of x matching y upto # y"

CON : { x @ CONN[ x ; y ] }
CON..h : "rows of text x CONtaining string y . See `CCONB for search details ."

CONB : { :[ &/ -3 = ( 4::' x ) , 4: y : VEC y ; CCONB . lower' ( x ; y ) ; x ~\: y ] }
CONB..h : "Boolean of rows of text x CONtaining string y , or  x ~/: y for non text"

CONN : { & CONB[ x ; y ] }
CONN..h : "Indexs of row of text x CON str y"

cover : { QW : ,/ coverraw[ x ; y ]
 QW : QW @ & |/ ( 1 >': ; 0 = )@\: 0< nestlevel QW
 ( _ ( # QW ) % 2 ; 2 ) # QW }
cover..h : " indices of top level cover of start/stop tokens `x  in string `y "

coverraw : { ( + y _ss/: x ) +\: 0 , # *| x }
coverraw..h : " indices of occurances of ( starting & ending ) toks in string "

csvcut : { ( nq 1 _ )' ( & uq[ d ] & d = "," ) _ d : "," , x }
csvcut..h : "split comma separated values"

CUT : { 1 _' ( & x ~\: * x ) _ x  }
CUT..h : "split x on occurances of first element"

cut : { CUT x , y }
cut..h : " cut y on occurances of x , deleting the y's . cf: `splt "

CUTel : { 1 _' ( & 0 = #:' x ) _ x : ( ,"" ) , x }
CUTel..h : " CUT x on empty lines "

cutOnEmpty : { 1 _ 1 _' ( 0 , & 0 = #:' x ) _ x }
cutOnEmpty..h : " cut list x on empty elements , eliminating the empties "

d : { ` $ ( $ x ) , "." , $ y }
d..h : "join-with-dot : (`x.y + `z.w -> `x.y.z.w) / from MK Rosenberg / inverse : `nd "

dicsabs : { d[ x ]' dics x }
dicsabs..h : " absolute paths of subdictionaries of dictionary `x "

find : { x @ & y _lin' !:' x : alldics x }
find..h : "sub dictionaries of x ( including x ) where symbol y is defined "

FNSCON : { x CONN[ $:' .:' x ; y ] }
FNSCON..h : "functions whose definitions contain string"

htmlallcut : { tokcut[ "<>" ] nencovered[ ( "<" ; ">" ) ] x }
htmlallcut..h : " cut html string eliminating all html tags "

htmlcut : { PRTBFs[ ; "</" , x ]'  PRTAF[ ; ">" ]' toksplt[ "<" , x ; y ] }
htmlcut..h : " splits html  y  on open and close tags  x "

htmlsplt : { PRTBFs[ ; "</" , x ]'  PRTAF[ ; ">" ]' toksplt[ "<" , x ; y ] }
htmlsplt..h : " split html string y on tag x , eg : htmlsplt[ \"table\" ] y "

in : { x @ & x _lin y }
in..h : " items matching in both  x  and  y "

IN : { x @ INN[ x ; y ] }
IN..h : "Lines of x matching y upto # y , case insensitive"

INB : { CINB . lower' ( x ; y ) }
INB..h : "Bool of char x matching y upto length of y , case insensitive "

INcln : { ( # y ) _/: IN[ x ; y ] }
INcln..h : " returns lines `IN x , dropping # x ; use on eg , .ldif files "

INN : { & INB[ x ; y ] }
INN..h : "indices of items of x matching y upto # y , case insensitive"

inside : { { y _ x }/[ y ; 1 -1 * #:' x ] }
inside..h : " returns string trimmed by lengh of tokens which cover it "

linv : { x @ & x _lin y }
linv..h : " like _lin but returns values selected "

lower : { ( _ci @[ ! 256 ; 65 + ! 26 ; + ; 32 ] ) @ _ic x }
lower..h : " convert to lower case . Mike Rosenberg collection . "

NCON : { x @ NCONN[ x ; y ] }
NCON..h : "rows of text x Not CONtaining string y"

NCONN : { ( ! # x ) _dvl CONN[ x ; y ] }
NCONN..h : "indices of rows of text x Not CONtaining string y"

nd : { ` $ cut[ "." ] @ $ x }
nd..h : " split symbols on dots . early from MKR "

nencovered : { y ( ! # y ) _dv/ ,/ ( -1 _ 1 _ ) @/: to ./: cover[ x ; y ] }
nencovered..h : " portion of y not covered between token pair x . "

nestlevel : { +\ ( ,/ ( ^ x ) # 1 -1 ) @ < ,/ x }
nestlevel..h : " level of nestng given list of start and close interval endpoints "

NIN : { x NINN[ x ; y ] }
NIN..h : "items of char x matching y upto length of y , case insensitive "

nin : { x @ & ~ x _lin y }
nin..h : " items of x not in y "

NINB : { ~ INB[ x ; y ] }
NINB..h : "bool of char x matching y upto length of y , case insensitive "

NINN : { & ~ INB[ x ; y ] }
NINN..h : "indices of char x matching y upto length of y , case insensitive "

nq : { x _dv "\"" }
nq..h : " Deletes quotes ( \" ) from string "

PRTAF : { ( 1 + x ? y ) _ x }
PRTAF..h : " Part After First y in x "

PRTBFs : { ( * x _ss y ) # x }
PRTBFs..h : "part of x before first occurance of string y"

sIN : { ` $ CIN[ $ x ; $ y ] }
sIN..h : " symbols IN . returns symbols x matching symbol y up to length of y "

sINN : { CINN[ $ x ; $ y ] }
sINN..h : " symbols IN . returns indices of symbols x matching symbol y up to length of y "

splt : { ( 0 , & y ~\: x ) _ y }
splt..h : " split y on occuraces of x . cf: `cut "

SPLTF : { ( 0 , x ? y ) _ x }
SPLTF..h : "split x on first y "

SPLTL : { | |:' SPLTF[ | x ; y ] }
SPLTL..h : "split x on last y"

SYMSCON : { ` $ CON[ $ x ; y ] }
SYMSCON..h : " symbols in list x containing str y "

SYMSCONB : { CONB[ $ x ; y ] }
SYMSCONB..h : " boolean where symbols in list x contain str y "

SYMSCONN : { CONN[ $ x ; y ] }
SYMSCONN..h : " indices where symbols in list x contain str y "

symsdotCON : { x @ & y _in' nd' x }
symsdotCON..h : " symbols in x containing symbol y as a subsymbol "

to : { x + ! y - x }
to..h : "integers from x upto but not including y  ; cf  `thru  "

tokcut : { ( # x ) _' ( y _ss x ) _ y : x , y }
tokcut..h : " split string `y at multi char token `x "

toksplt : { ( 0 , y _ss x ) _ y }
toksplt..h : " split string `y at multi char token `x , retaining tokens "

uq : { ~ b[ 0 ] |': b : (~=)\ x = "\"" }
uq..h : " unquote mask . [EMcD] "

VEC : { x , () }
VEC..h : " If atom , enlist  /  Was / { :[ @ x ; , x ; x ] } "