struct NamedTuple(**T)

• NamedTuple(**T)
• Value
• Object

Overview

A named tuple is a fixed-size, immutable, stack-allocated mapping of a fixed set of keys to values.

You can think of a NamedTuple as an immutable Hash whose keys (which are of type Symbol), and the types for each key, are known at compile time.

A named tuple can be created with a named tuple literal:

language = {name: "Crystal", year: 2011} # NamedTuple(name: String, year: Int32)

language[:name]  # => "Crystal"
language[:year]  # => 2011
language[:other] # compile time error

See NamedTuple literals in the language reference.

The compiler knows what types are in each key, so when indexing a named tuple with a symbol or string literal the compiler will return the value for that key and with the expected type, like in the above snippet. Indexing with a symbol or string literal for which there's no key will give a compile-time error.

Indexing with a symbol or string that is only known at runtime will return a value whose type is the union of all the types in the named tuple, and might raise KeyError.

Indexing with #[]? does not make the return value nilable if the key is known to exist:

language = {name: "Crystal", year: 2011}
language[:name]?         # => "Crystal"
typeof(language[:name]?) # => String

NamedTuple's own instance classes may also be indexed in a similar manner, returning their value types instead:

tuple = NamedTuple(name: String, year: Int32)
tuple[:name]   # => String
tuple["year"]  # => Int32
tuple[:other]? # => nil

Included Modules

• RayTracer::Color
• RayTracer::Tuple

Defined in:

Instance Method Summary

• #*(scalar : Float64)
• #*(scalar : Float32)
• #*(other : COLOR)
• #+(other : TUPLE)
• #+(other : COLOR)
• #-(other : TUPLE)
• #-(other : COLOR)
• #- : self
• #/(scalar : Float64)
• #/(scalar : Float32)
• #abs
• #b
• #cross(other : TUPLE)
• #dot(other : TUPLE)
• #g
• #magnitude
• #normalize
• #point?
• #r
• #reflect(normal : TUPLE)
• #vector?
• #w
• #x
• #y
• #z

Instance Method Detail