core

Module nu.core.

Nu core: every interaction a program is built from.

nu.core is the home of the atoms. Its own surface is the native standard terms - the builtins - and the three other atom families sit beside them as subpackages:

flows - control flow (Sequential, Parallel, Race, IfDo, WhileDo, Stream).
spans - transparent wrappers governing a region (Retry, Timeout, TryCatch, Transaction, Snapshot).
reactive - the reactivity standard: the observer contract plus the On*Change atoms fabrics bind against.

Everything under here is an Interaction. Forms (nu.forms), the kind taxonomy (nu.lang) and the fabric refs (nu.context, and the fabrics in nustd) are separate concerns with their own homes. The whole surface re-exports flat from the root, so day to day you write nu.Add / nu.Sequential / nu.Retry and never name this package.

The native standard terms

Concrete atoms layered on nu.lang's sort taxonomy - the kinds a real Nu program is built from. The goal is a 1:1 map of Python's native builtin functions (the ones that are not methods of a class) onto Nu interactions: abs -> Abs, getattr -> GetAttr, print -> Print. Library functions (itertools, functools, ...) are not core; they land in nustd in a later pass. Class methods land in extensions later too.

Files group atoms by Python domain, not by sort - one file per logical family, crossing Query / Command / Action as the builtins do:

literal - the constant-yielding ScalarQuery
arithmetic - numeric ops (Add, Sub, Mul, Pow, Abs, DivMod, Round)
comparison - ordering and identity (Eq, Lt, Gt, Is)
logical - boolean ops (And, Or, Not, ToBool)
conditional - value-yielding branch selection (If)
bitwise - bit ops (BitAnd, BitOr, BitXor, LShift)
cast - type construction / conversion (ToInt, ToStr, ToList, ToDict, ToSet)
repr - representations (Repr, Format, Bin, Hex, Ord, Chr)
access - item and attribute access (GetItem, Len, GetAttr, SetAttr)
iteration - iterator sources (Iter, Next, Enumerate, Zip, Reversed)
transform - stream-to-stream lenses (Map, Filter, Sorted, Flatten)
reduction - stream-to-scalar folds (Sum, Min, Max, AnyOf, AllOf, Collect)
reflection - introspection (Type, IsInstance, Callable, Id, Hash)
sentinel - the EMPTY / INVALID predicates (IsEmpty, IsInvalid)
io - console effects through the stdio fabric (Print, Input). Logging lives at nustd.logging -- a Python logging module wrap.
dynamic - host-namespace escape hatches (Globals, Locals)

This surface is the pure Python builtins. The fabric interactions (writing through a Ref into the Context store, a database, stdio) live in their own fabric dirs - nu.context owns SetCmd / Delete / AttrRef, not here - and the Forms layer (types, classes) has its own home at nu.forms. Flows and Spans (Seq, Par, If, Retry, Transaction) are the subpackages above.

Modules

Module	What
`nu.core.flows`	Nu2 Flow atoms: the Command-composing sub-kind.
`nu.core.spans`	Span atoms: transparent Interactions that wrap a body to govern a region.

arithmetic

Module nu.core.arithmetic.

Arithmetic atoms: Python's numeric builtins and operators.

Name	Sort	Call	Meaning
Abs	`scalar_query`	`Abs(value)`	The absolute value of its one child.
Add	`scalar_query`	`Add(*children)`	The sum of its scalar children.
Div	`scalar_query`	`Div(left, right)`	The first child divided by the second (true division).
DivMod	`scalar_query`	`DivMod(left, right)`	The `(quotient, remainder)` pair of its two children.
FloorDiv	`scalar_query`	`FloorDiv(left, right)`	The first child floor-divided by the second.
MatMul	`scalar_query`	`MatMul(left, right)`	The matrix product of its two children.
Mod	`scalar_query`	`Mod(left, right)`	The first child modulo the second.
Mul	`scalar_query`	`Mul(*children)`	The product of its scalar children.
Neg	`scalar_query`	`Neg(value)`	The arithmetic negation of its one child.
Pos	`scalar_query`	`Pos(value)`	The unary plus of its one child.
Pow	`scalar_query`	`Pow(base, exponent)`	The first child raised to the power of the second.
Round	`scalar_query`	`Round(value, ndigits)`	The first child rounded, to the second child's digits when given.
Sub	`scalar_query`	`Sub(left, right)`	The first child minus the second.

Name	Sort	Call	Meaning
AllOf	`reduction`	`AllOf(stream)`	True if every item in its stream child is truthy (`all`).
AnyOf	`reduction`	`AnyOf(stream)`	True if any item in its stream child is truthy (`any`).
Collect	`reduction`	`Collect(stream)`	Drains its stream child into one list value.
Count	`reduction`	`Count(stream)`	The number of items in its stream child (`len` over a stream).
First	`reduction`	`First(stream)`	The first item of its stream child.
Last	`reduction`	`Last(stream)`	The last item of its stream child.
Max	`reduction`	`Max(stream)`	The largest item in its stream child (`max`).
Min	`reduction`	`Min(stream)`	The smallest item in its stream child (`min`).
Sum	`reduction`	`Sum(stream)`	The sum of every item in its stream child (`sum`).

Name	Sort	Call	Meaning
And	`scalar_query`	`And(*children)`	The conjunction of its boolean children, each coerced with `bool`.
Not	`scalar_query`	`Not(value)`	The negation of its one child.
Or	`scalar_query`	`Or(*children)`	The disjunction of its boolean children, each coerced with `bool`.
ToBool	`scalar_query`	`ToBool(value)`	The truthiness of its one child.
bool		`core.bool(x)`	Coerce `x` to a Nu `Bool` term.

Name	Sort	Call	Meaning
Ascii	`scalar_query`	`Ascii(value)`	The `ascii` string of its one child, with non-ASCII escaped.
Bin	`scalar_query`	`Bin(value)`	The binary string (`0b...`) of its one integer child.
Chr	`scalar_query`	`Chr(value)`	The character for its one integer code-point child.
Format	`scalar_query`	`Format(value, spec)`	The `format` of a value under an optional format spec.
Hex	`scalar_query`	`Hex(value)`	The hexadecimal string (`0x...`) of its one integer child.
Oct	`scalar_query`	`Oct(value)`	The octal string (`0o...`) of its one integer child.
Ord	`scalar_query`	`Ord(value)`	The Unicode code point of its one single-character child.
Repr	`scalar_query`	`Repr(value)`	The `repr` string of its one child.

core

On this page