NamedTuple
struct NamedTuple(**T)
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 The compiler knows what types are in each key, so when indexing a named tuple with a symbol literal the compiler will return the value for that key and with the expected type, like in the above snippet. Indexing with a symbol literal for which there's no key will give a compile-time error.
Indexing with a symbol 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-
Defined in:
named_tuple.crjson/to_json.cr
yaml/to_yaml.cr
Class Method Summary
- .from(hash : Hash)
Creates a named tuple from the given hash, with elements casted to the given types.
- .new(pull : JSON::PullParser)
- .new(pull : YAML::PullParser)
- .new
Creates a named tuple that will contain the given arguments.
Instance Method Summary
- #==(other : NamedTuple)
Returns
trueif this tuple has the same keys as other, and values for each key are the same inselfand other. - #==(other : self)
Returns
trueif this tuple has the same keys as other, and values for each key are the same inselfand other. - #[](key : Symbol | String)
Returns the value for the given key, if there's such key, otherwise raises
KeyError- - #[]?(key : Symbol | String)
Returns the value for the given key, if there's such key, otherwise returns
nil. - #clone
Returns a named tuple with the same keys but with cloned values, using the
#clonemethod. - #each(&block) : Nil
Yields each key and value in this named tuple.
- #each_key(&block) : Nil
Yields each key in this named tuple.
- #each_value(&block) : Nil
Yields each value in this named tuple.
- #each_with_index(offset = 0, &block)
Yields each key and value, together with an index starting at offset, in this named tuple.
- #empty?
Returns
trueif this named tuple is empty. - #fetch(key : Symbol | String, default_value)
Returns the value for the given key, if there's such key, otherwise returns default_value.
- #fetch(key : Symbol, &block)
Returns the value for the given key, if there's such key, otherwise the value returned by the block.
- #fetch(key : String, &block)
Returns the value for the given key, if there's such key, otherwise the value returned by the block.
- #from(hash : Hash)
Expects to be called on a named tuple whose values are types, creates a tuple from the given hash, with types casted appropriately.
- #has_key?(key : String) : Bool
Returns
trueif this named tuple has the given key,falseotherwise. - #has_key?(key : Symbol) : Bool
Returns
trueif this named tuple has the given key,falseotherwise. - #hash
Returns a hash value based on this name tuple's size, keys and values.
- #inspect
Same as
#to_s. - #keys
Returns a
Tupleof symbols with the keys in this named tuple. - #map(&block)
Returns an
Arraypopulated with the results of each iteration in the given block, which is given each key and value in this named tuple- - #pretty_print(pp)
- #size
Returns the number of elements in this named tuple.
- #to_a
Returns a new
Arrayof tuples populated with each key-value pair- - #to_h
Returns a
Hashwith the keys and values in this named tuple. - #to_json(json : JSON::Builder)
- #to_s(io)
Appends a string representation of this named tuple to the given
IO- - #to_yaml(yaml : YAML::Builder)
- #values
Returns a
Tuplewith the values in this named tuple.
Instance methods inherited from struct Value
==(other) ==, dup dup Instance methods inherited from class Object
!=(other) !=, !~(other) !~, ==(other) ==, ===(other : JSON::Any)===(other : YAML::Any)
===(other) ===, =~(other) =~, class class, dup dup, hash hash, inspect(io : IO)
inspect inspect, itself itself, not_nil! not_nil!, pretty_inspect(width = 79, newline = "\n", indent = 0) : String pretty_inspect, pretty_print(pp : PrettyPrint) : Nil pretty_print, tap(&block) tap, to_json(io : IO)
to_json to_json, to_pretty_json(indent : String = " ")
to_pretty_json(io : IO, indent : String = " ") to_pretty_json, to_s
to_s(io : IO) to_s, to_yaml(io : IO)
to_yaml to_yaml, try(&block) try
Class methods inherited from class Object
from_json(string_or_io, root : String) : selffrom_json(string_or_io) : self from_json, from_yaml(string_or_io) : self from_yaml
Class Method Detail
def self.from(hash : Hash)Source
Creates a named tuple from the given hash, with elements casted to the given types. Here the Int32 | String union is cast to Int32.
num_or_str = 42.as(Int32 | String)
NamedTuple(name: String, val: Int32).from({"name" => "number", "val" => num_or_str}) # => {name: "number", val: 42}
num_or_str = "a string".as(Int32 | String)
NamedTuple(name: String, val: Int32).from({"name" => "number", "val" => num_or_str}) # raises TypeCastError (cast from String to Int32 failed) See also: #from.
def self.new(pull : JSON::PullParser)Source
def self.new(pull : YAML::PullParser)Source
def self.newSource
Creates a named tuple that will contain the given arguments.
This method is useful in macros and generic code because with it you can creates empty named tuples, something that you can't do with a tuple literal.
NamedTuple.new(name: "Crystal", year: 2011) #=> {name: "Crystal", year: 2011}
NamedTuple.new # => {}
{} # syntax error
Instance Method Detail
def ==(other : NamedTuple)Source
Returns true if this tuple has the same keys as other, and values for each key are the same in self and other.
tuple1 = {name: "Crystal", year: 2011}
tuple2 = {year: 2011, name: "Crystal"}
tuple3 = {name: "Crystal", year: 2012}
tuple4 = {name: "Crystal", year: 2011.0}
tuple1 == tuple2 # => true
tuple1 == tuple3 # => false
tuple1 == tuple4 # => true
def ==(other : self)Source
Returns true if this tuple has the same keys as other, and values for each key are the same in self and other.
tuple1 = {name: "Crystal", year: 2011}
tuple2 = {year: 2011, name: "Crystal"}
tuple3 = {name: "Crystal", year: 2012}
tuple4 = {name: "Crystal", year: 2011.0}
tuple1 == tuple2 # => true
tuple1 == tuple3 # => false
tuple1 == tuple4 # => true
def [](key : Symbol | String)Source
Returns the value for the given key, if there's such key, otherwise raises KeyError-
tuple = {name: "Crystal", year: 2011}
key = :name
tuple[key] # => "Crystal"
key = "year"
tuple[key] # => 2011
key = :other
tuple[key] # raises KeyError
def []?(key : Symbol | String)Source
Returns the value for the given key, if there's such key, otherwise returns nil.
tuple = {name: "Crystal", year: 2011}
key = :name
tuple[key]? # => "Crystal"
key = "year"
tuple[key] # => 2011
key = :other
tuple[key]? # => nil
def cloneSource
Returns a named tuple with the same keys but with cloned values, using the #clone method.
def each(&block) : NilSource
Yields each key and value in this named tuple.
tuple = {name: "Crystal", year: 2011}
tuple.each do |key, value|
puts "#{key} = #{value}"
end Output:
name = Crystal year = 2011
def each_key(&block) : NilSource
Yields each key in this named tuple.
tuple = {name: "Crystal", year: 2011}
tuple.each_key do |key|
puts key
end Output:
name year
def each_value(&block) : NilSource
Yields each value in this named tuple.
tuple = {name: "Crystal", year: 2011}
tuple.each_value do |value|
puts value
end Output:
Crystal 2011
def each_with_index(offset = 0, &block)Source
Yields each key and value, together with an index starting at offset, in this named tuple.
tuple = {name: "Crystal", year: 2011}
tuple.each_with_index do |key, value, i|
puts "#{i + 1}) #{key} = #{value}"
end Output:
1) name = Crystal 2) year = 2011
def empty?Source
Returns true if this named tuple is empty.
tuple = {name: "Crystal", year: 2011}
tuple.empty? # => false
def fetch(key : Symbol | String, default_value)Source
Returns the value for the given key, if there's such key, otherwise returns default_value.
tuple = {name: "Crystal", year: 2011}
tuple.fetch(:name, "Unknown") # => "Crystal"
tuple.fetch("year", 0) # => 2011
tuple.fetch(:other, 0) # => 0
def fetch(key : Symbol, &block)Source
Returns the value for the given key, if there's such key, otherwise the value returned by the block.
tuple = {name: "Crystal", year: 2011}
tuple.fetch(:name) { "Unknown" } # => "Crystal"
tuple.fetch(:other) { 0 } # => 0
def fetch(key : String, &block)Source
Returns the value for the given key, if there's such key, otherwise the value returned by the block.
tuple = {name: "Crystal", year: 2011}
tuple.fetch("name") { "Unknown" } # => "Crystal"
tuple.fetch("other") { 0 } # => 0
def from(hash : Hash)Source
Expects to be called on a named tuple whose values are types, creates a tuple from the given hash, with types casted appropriately. The hash keys must be either symbols or strings.
This allows you to easily pass a hash as individual named arguments to a method.
require "json"
def speak_about(thing : String, n : Int64)
"I see #{n} #{thing}s"
end
data = JSON.parse(%({"thing": "world", "n": 2})).as_h
speak_about(**{thing: String, n: Int64}.from(data)) # => "I see 2 worlds"
def has_key?(key : String) : BoolSource
Returns true if this named tuple has the given key, false otherwise.
tuple = {name: "Crystal", year: 2011}
tuple.has_key?(:name) # => true
tuple.has_key?(:other) # => false
def has_key?(key : Symbol) : BoolSource
Returns true if this named tuple has the given key, false otherwise.
tuple = {name: "Crystal", year: 2011}
tuple.has_key?(:name) # => true
tuple.has_key?(:other) # => false
def hashSource
Returns a hash value based on this name tuple's size, keys and values.
See also: Object#hash.
def keysSource
Returns a Tuple of symbols with the keys in this named tuple.
tuple = {name: "Crystal", year: 2011}
tuple.keys # => {:name, :year}
def map(&block)Source
Returns an Array populated with the results of each iteration in the given block, which is given each key and value in this named tuple-
tuple = {name: "Crystal", year: 2011}
tuple.map { |k, v| "#{k}: #{v}" } # => ["name: Crystal", "year: 2011"]
def pretty_print(pp)Source
def sizeSource
Returns the number of elements in this named tuple.
tuple = {name: "Crystal", year: 2011}
tuple.size # => 2
def to_aSource
Returns a new Array of tuples populated with each key-value pair-
tuple = {name: "Crystal", year: 2011}
tuple.to_a # => [{:name, "Crystal"}, {:year, 2011}]
def to_hSource
Returns a Hash with the keys and values in this named tuple.
tuple = {name: "Crystal", year: 2011}
tuple.to_h # => {:name => "Crystal", :year => 2011}
def to_json(json : JSON::Builder)Source
def to_s(io)Source
Appends a string representation of this named tuple to the given IO-
tuple = {name: "Crystal", year: 2011}
tuple.to_s # => %({name: "Crystal", year: 2011})
def to_yaml(yaml : YAML::Builder)Source
def valuesSource
Returns a Tuple with the values in this named tuple.
tuple = {name: "Crystal", year: 2011}
tuple.values # => {"Crystal", 2011}
© 2012–2017 Manas Technology Solutions.
Licensed under the Apache License, Version 2.0.
https://crystal-lang.org/api/0.22.0/NamedTuple.html
