Objects (type)#

Declaration#

type Person {
  name: String!
  age: Int! = 0

  greet: String! {
    "hi, I'm " + name
  }
}

• declares a type Person and a constructor function Person
• members are fields or methods, indistinguishable in syntax (name + optional : Type, = default, or { body }); let makes a member private

Public vs. private members#

• a bare member is public — readable from outside the type; public is the default for a type
• let — private to the declaring module: readable by any type or method in the same module, rejected across a module boundary (see Modules and imports)
• pub is still accepted as an explicit public marker, but it is redundant and dang fmt removes it (see Fields)
• whether a member is a constructor parameter depends on having NO default, NOT on visibility:
  • x: T! (no default) → required positional param
  • x: T! = d → optional param (default d)
  • let x: T! (no default) → required positional param too, e.g. Foo("public_value", "private_value")
  • let x: T! = d → NOT a param; the default is used
  • method/computed members (have a { body }) are never constructor params

# `let` privacy is module-scoped, not type-scoped: another type in the same
# module reaches a let member (across a module boundary it is rejected)
type Account { let secret: String! = "hunter2" }
type Vault { unlock(a: Account!): String! { a.secret } }
Vault.unlock(Account)   # "hunter2"

Implicit constructor#

• one positional parameter per non-default field, in declaration order (NOT required-first-then-defaults — a defaulted field may precede a required one; positional args still line up by declaration order)
  • e.g. Mixed { pub publicWithDefault = "default"; let privateRequired: Int! } constructs as Mixed("default", 42)
• can also be called with named arguments (Counter(value: 42))
• field defaults are evaluated with self bound, so a default may reference earlier/sibling fields, e.g. combined = prefix + "_" + suffix

Person("Alice", age: 30)
Person(name: "Alice")

Zero-arg auto-construction#

• a type whose constructor needs nothing (all fields have defaults / no required params) constructs on bare reference: let p = Person ≡ let p = Person()
• a bare reference to a function requiring a block argument is an error (function requires a block argument) — same as calling it without a block; use &name to reference it without calling

Explicit constructor: new#

type Greeter {
  greeting: String!

  new(name: String!) {
    self.greeting = "hello, " + name
    self
  }
}

• declared as new(args) { body } or new { body } (no parens when no args)
• no pub and no return-type annotation — both are errors ("'new' is a constructor, not a method")
• new is only valid inside a type body
• overrides the implicit constructor (the type's fields no longer auto-become params; new's arg list defines the signature)
• constructor args are local bindings — distinct from fields, even when same-named:
  • mutable: foo = foo + 10 / foo += foo rebinds the arg, does NOT touch self.foo
  • shadow same-named fields and outer scope; bare name = arg, field write needs self.field =
  • NOT visible in method bodies — only in new
• must return the constructed type (self, or a method chain that returns it): body's last expression must be Foo!
  • returning another type errors: new() must return Wrong!, got String!
  • returning null errors
• may end by chaining other methods, which propagate their forked self, e.g. self.withSuffix("!")
• self-field mutation inside a loop accumulates into one fork
• can accept block args: new(&condition: Boolean!) { ... }; a block param uses &name

self#

• bound during constructor and method execution (and during field-default / computed-field evaluation)
• bare names inside a method resolve against the current receiver first: bare name reads self.name, bare incrBy(1) calls self.incrBy(1)
• field reads never need self.; for assignment, both forms work:
  • bare a += 1 / value = v on a field forks self and sets the field
  • self.field = ... is the explicit form; required only to disambiguate from a same-named local/arg
  • bare assignment binds a local/arg when the name is one in scope (shadowing); otherwise targets the field
• assigning a field forks the receiver (see Mutation and copy-on-write)
• self is the value returned by chainable methods (the final self returns the accumulated fork)

Computed fields#

• a member with a type and a body but no arg list is a computed field — a zero-arg function evaluated on self each access:

fullName: String! { firstName + " " + lastName }

• accessed like a plain field (obj.fullName, no call parens); recomputes against the current receiver
• a defaulted-value member (pub computedField = config.name + "_computed") is computed once at construction; a { body } computed field is re-evaluated per access

Static members#

type Color {
  r: Int! = 0
  g: Int! = 0
  b: Int! = 0

  luminance: Int! { (r + g + b) / 3 }        # an instance member

  # a self { } block declares statics: they live on the type itself, reached as
  # Color.member, never on an instance
  self {
    white: Color! { Color(r: 255, g: 255, b: 255) }   # a factory method
    fromGray(v: Int!): Color! { Color(r: v, g: v, b: v) }
    grayMid: Color! { fromGray(128) }                 # a static calling a sibling static
    let scale = 2                                      # a private (let) static helper
    doubled(v: Int!): Int! { v * scale }
  }
}

Color.white.luminance          # 255
Color.fromGray(10).r           # 10
Color.grayMid.g                # 128
Color.doubled(7)               # 14
Color(r: 3, g: 6, b: 9).luminance   # 6 — instances are unaffected by statics
Color.luminance                # 0 — a bare all-default type still auto-constructs

# static stored fields hold singleton state on the type
type Config {
  host: String! = "localhost"
  self {
    limit: Int! = 100
    default: Config! = Config    # a static holding a constructed instance
  }
}

Config.limit          # 100
Config.default.host   # "localhost"

• a scalar may also carry a self { } block — including static stored fields, even though instance stored fields on a scalar are forbidden (see Scalar bodies)

Implements#

type Person implements Named & Identifiable { name: String!; id: String! }

• see Interfaces and unions

Forward references#

• methods can reference types and fields defined later in the same file
• references also resolve across files in a directory module, order-independently
• defaults can reference sibling fields (evaluated with self bound)