Features

This numbered inventory covers the intended language, execution, visualization and physics design. Section 0 is authoritative wherever later direction conflicts. Inclusion means design scope, not implemented or verified support. The examples and syntax reference supply compiler correction targets.

1. Mathematical source. Express values, relationships and transformations in a compact, keyword-free language.
2. Demand-driven execution. Compute only values needed by observations or dependencies.
3. Partial demand. Evaluate selected regions when dependency analysis permits it.
4. Fusion and materialization. Avoid unnecessary intermediates; choose streaming, caching, recomputation and storage from observable semantics.
5. Compiler-managed compute. Select SIMD, parallel CPU or GPU execution without source-level kernel launches or memory transfers.
6. Semantic optimization contracts. Substitute equivalent BLAS, sparse, physics or rendering implementations using semantic traits rather than function names alone.
7. One semantic graph. Represent ordinary, symbolic, lazy, transform and optimizer expressions with common types, shapes, dimensions, domains, effects and provenance.
8. Compile-time evaluation. Partially evaluate known graph regions without introducing a separate expression language.
9. Numerical correctness contracts. Preserve evaluation order, domains and serial observations; reassociate reductions only when permitted.
10. Orthogonal meaning. Keep properties, structural dimensions, numerical domains, physical dimensions, units, quantity kinds, functions, Laws, Embeddings and execution strategy distinct.
11. Bindings and updates. Declare with name:; update an existing binding with .name:; support lexical shadowing without accidental redeclaration.
12. Expression-valued scopes. Use indentation or parentheses for scopes, final expressions for results and bare : for scope records.
13. Tuple structure. Distinguish tuples, singleton tuples and named tuples from vector dimensions.
14. Vector structure. Square brackets add rank; support nested, fixed and dynamic vector values.
15. Lazy vectors. Use ordinary vectors for large and infinite values, without a separate generator/yield construct.
16. Inclusive ranges. Support finite, descending and unbounded ranges; distinguish iteration positions from coordinate values.
17. Typed repetition and emptiness. Repetition preserves element type and rank at zero length; empty demand performs no element work.
18. Anonymous dimensions. Give unnamed axes positional identity, separate from named axes.
19. Named dimensions. Attach single-letter structural dimensions to values; numbers remain coordinates or values.
20. Complete rank naming. Require a suffix to name the entire rank unless an explicit structural ellipsis is present.
21. Structural ellipsis. Allow one ASCII ... to retain the required anonymous dimensions, including zero dimensions.
22. Named alignment. Align dimensions by identity and require compatible sizes; never silently resize aligned values.
23. Anonymous alignment. Align anonymous axes only with compatible anonymous positions; never silently map them onto named axes.
24. Diagonal selection. Repeated value-selection names identify equal coordinates, as in A_ii, according to Section 0.
25. Elementwise arithmetic. Align/lift + - * / // % ^; multiplication does not imply contraction.
26. Two comparison levels. Distinguish elementwise comparisons/logical operations from whole-value == and !=.
27. Concatenation. Join values along an explicit dimension or a uniquely inferable dimension.
28. Composition and function arithmetic. Compose first-class functions and apply compatible pointwise operators to them.
29. Callable operators. Use operators as function values, including indexed collections and specialization.
30. Ordinary lifting. Lift compatible function calls by argument structure; preserve tuple/record atomicity and exact container-overload priority.
31. Structural calls. Pass selected dimensions intact to a function and lift over the remainder; result structure determines which axes survive.
32. Ordered folds. Reduce one indexed collection with one binary reducer and one initial accumulator.
33. Multidimensional reductions. Remove exactly the selected dimensions; reject repeated reduction selectors.
34. Named reductions and identities. Provide sum, product and function-chain reductions with their defined empty identities.
35. Recurrence. Express state evolution through ordered folds or specialized function chains, including multiple varying inputs.
36. Explicit specialization. Distinguish f(...) evaluation from f[...] binding, including zero-argument bound callables.
37. Indexed specialization. Lift argument binding to form dimensioned collections of specialized functions.
38. Ordinary argument binding. Declare parameters in parentheses and specialize ordinary named arguments with square brackets at the call site.
39. Alphabetic structural selectors. Select named value dimensions with alphabetic suffixes; the former bracketed compile-time parameter declarations are removed.
40. Ordinary underscore identifiers. Resolve exact names before interpreting structural suffixes where appropriate.
41. Ordinary call arguments. Support positional, named, typed and default arguments using one call model.
42. Runtime spilling. Spill ordinary vectors, tuples or named tuples with prefix :; do not use call-site ... for runtime spreading.
43. Runtime variadics. Capture remaining positional/named arguments using the core declaration grammar; process forwarding reuses that grammar.
44. Generic types and shapes. Infer compile-time type/extent parameters consistently across parameter and result structures.
45. Overloads and type dispatch. Select compatible ordinary functions, operators and dotted-access overloads.
46. Closures and declarations. Support lambdas, captured values, recursion, higher-order functions and forward declarations with source-order effects preserved.
47. Nominal values. Construct uppercase nominal types with spill-backed structure; reconstruct compatible operations without losing nominal identity.
48. Type and member reflection. Expose actual types, ordered record keys, member selection and structural type spilling.
49. Modules and lexical qualification. Import module handles, alias or spill exports, and preserve captured qualified meanings under shadowing.
50. Symbolic numerical domains. Declare real, complex, continuous or discrete domains authoritatively rather than guessing from variable names.
51. Assumption-preserving simplification. Retain domains, singularities and principal complex behavior during symbolic inspection and numerical lowering.
52. Exact differentiation. Use function-variable transforms and ordinary calculus; keep finite differences separate.
53. Integration and bound specialization. Select formal variables, introduce absent variables, bind general bounds and override them with variable-specific bounds.
54. Physical-domain qualification. Use Domain[Dimension], including vector and complex domains, without conflating it with multiplication or display units.
55. SI physical dimensions. Represent seven base dimensions with rational compile-time exponents and algebraically derived dimensions.
56. Unit definitions and canonical SI. Define scale, physical dimension, symbols and quantity kind once; resolve conversion statically where possible.
57. Whole-value units. Give a scalar, vector or matrix one quantity representation rather than per-element unit metadata.
58. Dimensional compatibility. Require compatible dimensions for addition, subtraction and comparison.
59. Left-operand representation. Preserve the left operand's preferred unit in compatible addition and subtraction.
60. Multiplicative dimensions. Derive dimensions through multiplication/division and recognize named derived units without new base dimensions.
61. Explicit conversion views. Use .to(unit) to change preferred representation while preserving the physical quantity, canonical SI backing and aliases.
62. Dimensionless quantities and angles. Separate ordinary dimensionless values from angle-kind quantities; radians/degrees share physical dimension one.
63. Unit-aware trigonometry. Accept dimensionless numbers and canonical-radian angle magnitudes; reject dimensional arguments.
64. Exponential and logarithmic domains. Require dimensionless inputs; preserve Euler's relation for angle quantities and return ordinary dimensionless exponential output.
65. Dimensional powers. Require dimensionless exponents and normally compile-time-known powers for dimensional bases; support rational resulting dimensions.
66. Units through reductions. Preserve dimensions through sum/mean/min/max, square them for variance and restore them for standard deviation.
67. Units through calculus. Derive derivative dimensions by division and integral dimensions by multiplication with the variable's dimension.
68. Symbolic dimensional validation. Reject physically inconsistent symbolic expressions before numerical evaluation.
69. Quantity output and display policy. Print units automatically; support automatic SI prefixes, configured precision/preferences and explicit conversion priority.
70. Semantic LaTeX. Render numerical domains, physical dimensions, concrete units, derived units and angles from the same definitions used by printing and plots.
71. Strings and templates. Support immediate/deferred interpolation, member selection, static/dynamic formats and vectorized .format with ordinary spilling.
72. Conditions and matching. Use expression-valued conditionals, value/type matching, implication and an unlabelled fallback arm.
73. Pipes and coordinates. Expose current/outer values and named coordinates; distinguish progressive pipes from explicitly nested scopes.
74. Loops and early control. Support conditional/matching loops, numbered read-only loop indices, continue, break and early return with scope-correct behavior.
75. Typed errors and assertions. Construct, raise, match and propagate typed errors; retain source locations through compiler lowering.
76. Multisets. Support counted values, exact element types, count-combining operations and multiset type values.
77. Connected topology. Use u,v,w for curves/surfaces/volumes, c for components and t for time in the later integration direction, without overriding Section 0's ordinary dimension rules.
78. Generic groups and coordinate labels. Give ordinary grouping dimensions no object-specific meaning; associated coordinates/labels align with their own dimension.
79. Explicit topology and references. Describe edges, faces and volume elements with reference values and m member slots connecting independent entity groups.
80. Subsets and sparse properties. Attach properties to referenced selections rather than filling parent collections with null entries.
81. Compositional plot lifecycle. Define persistent defaults, one-layer add, composed-state push, append, show and plot through their ordinary operations.
82. Frame and world layers. Separate render/data layers from simulation-capable layers while consuming the same ordinary values.
83. Positions, components and Embeddings. Map Cartesian/polar/spherical, complex and higher-component data into perception without making rendering dictate physical state.
84. Styling, colormaps and interpolation. Use ordinary per-property/per-primitive functions, structures and dimension-aware suffixes rather than parallel plot-type/color-by systems.
85. Limits and modes. Support combined/side-specific limits, dimensional configuration and extend/clamp/repeat/mirror/discard behavior where meaningful.
86. Cameras and shared multi-view geometry. Represent camera position/target/projection as ordinary structures; let views vary while invariant geometry remains shared.
87. Compositional axes and labels. Generate axes, grids, ticks and text as ordinary layers; propagate quantity units into default labels.
88. Symbolic plots, relations and roots. Use the ordinary plotting API for expressions, equations and inequalities; infer geometric dimension and map complex roots through components.
89. Adaptive symbolic rendering. Refine with zoom, curvature, discontinuities, singularities, cusps, asymptotes and domain boundaries while retaining true nonsmoothness.
90. Motion and kinematic constraints. Distinguish initial from time-prescribed p/v/a; apply position > velocity > acceleration > Laws, including deterministic collision interaction.
91. Unified physical Laws and solver choice. Evolve ordinary properties with ordinary functions; permit rigid/continuum and hybrid APIC/FLIP/MLS-MPM/sparse-grid backends, adaptive resolution, sleeping, splitting/merging and GPU fusion.
92. Lighting and derived views. Use emissive layers and derived camera views for lighting, mirrors, screens, portals and camera feeds.
93. Processes. Start ordinary functions in isolated event/I/O contexts; return their results from join and permit forced kill without a separate argument-packing language.
94. Queues and event loops. Deliver each FIFO item to one receiver; suspend efficiently and re-evaluate matching-loop receives each iteration.
95. Broadcast. Deliver publications to every active subscriber, preserve per-producer order and clean up subscriptions with lifetime where possible.
96. Shared ordinary storage. Share one arbitrary ordinary value; preserve type, shape and dimensions across CPU/GPU/shared/mapped/lazy backing and bulk-data handles/views.
97. Immutable published generations. Support one logical writer and multiple readers with unobservable buffer reuse, swaps or copy-on-write; the public generation-update API remains unresolved.
98. Semantic highlighting. Color nested vector depth and resolved dimension identities; keep anonymous axes neutral and distinguish compile-time literal suffixes from ordinary underscore identifiers.
99. Unresolved surface design. Track deterministic external-resource cleanup, complete UI binding/control syntax, unit/suffix precedence and final process variadic spelling explicitly; invent none of them in implementation-facing examples.
100. End-to-end language acceptance. Require coherent original-source behavior across compilers and targets, including Section 0's Mandelbrot, finite complex power-tower and infinite convergence visual integration cases; example counts alone do not establish completion.

All implementation and verification statuses remain separate from this inventory. No benchmarks, downloads, build results or platform-support claims are implied.