ezsys

Search uses release 0.1.0.0 · 176 definitions

Releases (1)

0.1.0.0 indexed

Definitions (176)

src/str.bend

def text.replace.ata nonempty `old` at this character, or not: write `new` and pass over the rest of `old`, or write the character
def text.replace.gothe scan for a nonempty `old`; `skip` characters of a found `old` are still to pass over
def text.replace.gapsan empty `old`: `new` after every character
def text.replaceevery `old` replaced by `new`, left to right, never overlapping; an empty `old` puts `new` before every character and at the end
def text.split.pusha character on the front of the first piece
def text.split.ata separator at this character ends a piece; else the character starts it
def text.split.gothe scan for a nonempty separator; `skip` characters of a found separator are still to pass over
def text.splitthe pieces between the separators, in order; an empty separator splits nothing
def text.find.inca place one character further on
def text.find.atthe needle here, or further on
def text.find.endat the end of the text only an empty needle is found
def text.findthe index, in code points, of the first place the needle starts
type Rulea run of code points `lo` to `hi`, every `step`-th one from `lo`, mapped in order onto the code points from `to`
type Multia code point that maps to more than one
def text.case.coverswhether a rule maps the code point
def text.case.targetwhere a rule maps a code point it covers
def text.case.pickthe first rule's mapping, or the rest's
def text.case.applythe code point the first rule that covers it maps it to; itself when none does
def text.case.foundthis entry's text, or the rest's
def text.case.multithe text a code point that maps to more than one maps to
def text.case.onea multiple mapping's text, or the rules' one code point
def text.case.ofa code point mapped by a table: its multiple mapping, else the rules
def text.lower.rulesUnicode 13's lowercase mappings (Python's str.lower) of U+0000 to U+017F and U+0370 to U+04FF that are one code point
def text.lower.multithe lowercase mapping of U+0130 is two code points
def text.upper.rulesUnicode 13's uppercase mappings (Python's str.upper) of U+0000 to U+017F and U+0370 to U+04FF that are one code point
def text.upper.multithe uppercase mappings of U+00DF, U+0149, U+0390 and U+03B0 are more than one code point
def text.lower.charone character in lowercase
def text.upper.charone character in uppercase
def text.lowerthe text in lowercase, character by character
def text.upperthe text in uppercase, character by character
def text.pad_rightthe text with spaces after it up to `n` code points; a longer text is kept whole
def text.truncatethe first `n` code points of the text, or all of it when it is shorter
def text.digits.zero.ifa leading '0' is dropped, and the zeros after it
def text.digits.trimthe text with its leading '0's removed
def text.digits.bythe longer text is the greater; texts of one length compare code point by code point
def text.digits.cmptwo digit strings in numeric order: leading zeros dropped, then the longer is the greater, and two of one length compare digit by digit

src/sys.bend

def ezsys.renameflush `from` to disk, then rename it over `to`
def ezsys.clockwhole seconds since 1970-01-01T00:00:00Z and the milliseconds past them
def ezsys.listthe names in a directory as the host lists them, in its order
def sys.read.fuelreads one file.read makes at most
def sys.read.endclose the file, then answer
def sys.read.nextact on one read's step: read on, or close and answer
def sys.read.ununpack a read's file and answer
def sys.read.goread chunks until an empty one; fuel first, so the call is a decreasing one
def sys.read.sizedthe file's size decides the chunk; a failed size is the answer
def sys.read.openedan opened file is sized and read; a failed open is the answer
def sys.reada whole file's text
def sys.write.doneclose the file, then answer the write's result
def sys.write.openedwrite to an opened file; a failed open is the answer
def sys.writea file's whole text replaced (created when missing)
def sys.save.nextrename the written temporary file, or answer the write's failure
def sys.savewrite `<path>.tmp`, then rename it over path
def sys.envan environment variable, or the fallback when it is unset
def sys.now_isothe wall clock's ISO 8601 UTC text
def sys.lista directory's names, less "." and "..", sorted; a failed read is the answer

src/text.bend

type Modewhere the scan is: in plain text, passing over the rest of an open delimiter, inside a key, or passing over the rest of a close delimiter
def text.Pairsthe keys and values, reusable
def text.owna caller's pairs as reusable ones, in their order
def text.value.pickthis pair's value when its key is the one asked for, else the rest's
def text.valuethe value a key names: the first pair with that key
def text.tailthe characters of a delimiter after its first
def text.enterthe mode after an open delimiter's first character, with `left` to pass
def text.leavethe mode after a close delimiter's first character, with `left` to pass
def text.putwhat a finished marker becomes: its value, or the marker as written
def text.plaina character in plain text: the start of a marker, or itself
def text.shuta character in a key: the start of the close delimiter, or part of the key
def text.stepone character: what it writes and the mode after it
def text.endthe end of the template: an unclosed marker is written as it was
def text.joinwrite a step's text, then scan on in the mode after it
def text.gothe scan
def text.anytrue when here is true, else what the rest says
def text.allfalse when here is false, else what the rest says
def text.markedwhether an open delimiter starts anywhere in the text
def text.freewhether no close delimiter starts at any character of key, in key ++ after
def text.fill_withevery marker between open and close replaced by its key's value
def text.fillevery `{{key}}` marker replaced by its key's value