Values & Types

The deterministic value set

Sense type	Example	Notes
`Int`	`42`	whole numbers
`Float`	`3.14`	`/` always produces a `Float`, even `Int / Int`
`String`	`"hi\n"`	escapes: `\n \t \" \\ \r`
`Bool`	`true`, `false`	distinct from `Int` — `true == 1` is `false`
`Nil`	`nil`	absence of a value
`Array`	`[1, 2, 3]`	heterogeneous, 0-indexed, mutable
`Function`	`def square(x): return x * x`	closes over its defining scope

These are the values every Sense program can use with zero AI involvement and zero network access — the deterministic core is a complete, ordinary programming language on its own. See Non-Goals for why that’s a deliberate design commitment, not an implementation detail.

Values that extend the model

As you move into Sense’s AI-native and safety features, a few more value kinds appear — each documented in depth on its own page:

Model

A runtime reasoning resource — never a raw API handle.

Answer

The result of ask(...): a value, a confidence, and a source — never silently just “a string.”

Agent

A runtime entity with identity, persistent state, and a lifecycle.

Action

A prepared-but-not-yet-executed world-changing operation.

Truthiness

nil, false, 0, 0.0, "", and [] are falsy. Everything else — including any non-empty string or array — is truthy:

if "":
    print("not reached")
if "x":
    print("reached")
if []:
    print("not reached")

Operators

Arithmetic
Comparison
Logic
String / Array +

+ - * / % — standard precedence. / is always true (float) division; there’s no separate integer-division operator yet.

print(7 / 2)   # 3.5
print(7 % 2)   # 1

== != < <= > >= — these stay symbolic on purpose. Arithmetic and comparison operators are already the same notation math uses; there’s no “more natural” alternative worth reaching for, unlike logic words (see next tab).==/!= never conflate Bool with Int/Float, even though many languages let true == 1:

print(true == 1)   # false
print(1 == 1)      # true

and, or, not — words, not symbols (&&/||/!), because these are exactly the place where a natural-language word reads more clearly than a symbol without losing precision.

if age >= 18 and has_id:
    allow()
if not verified:
    deny()

+ concatenates two Strings or two Arrays. Mixing a String with a non-String is a runtime error — use str(x) to convert explicitly; Sense never silently stringifies for you.

print("a" + "b")     # "ab"
print([1] + [2])     # [1, 2]
print("x" + 1)        # error — use "x" + str(1)

Type annotations are a runtime check, not static inference

x: Int = 5
def square(n: Int) -> Int:
    return n * n

Annotations are checked with values.matches_type() at the point of assignment, call, and return — a shallow, honest runtime check, not a real type system. Array<T> checks element types recursively; Any accepts anything; an unrecognized type name is currently unenforced.

Real static type checking — including how the type system should represent Answer<T>’s reliability — is an open research question in Sense’s design log, deliberately deferred rather than bolted on twice. See Roadmap.

Continue

Variables & scope

The one assignment rule, and how local gives you intentional shadowing.

Functions

def/-> — the one concept shaped just like Python’s own.

Language

AI-Native

Safety

Values & Types

The deterministic value set

Values that extend the model

Model

Answer

Agent

Action

Truthiness

Operators

Type annotations are a runtime check, not static inference

Continue

Variables & scope

Functions

​The deterministic value set

​Values that extend the model

Model

Answer

Agent

Action

​Truthiness

​Operators

​Type annotations are a runtime check, not static inference

​Continue

Variables & scope

Functions

The deterministic value set

Values that extend the model

Truthiness

Operators

Type annotations are a runtime check, not static inference

Continue