module Erlang
Constants
- EmptyAtom
The canonical empty `Atom`. Returned by `Atom[]` when invoked with no arguments; also returned by `Atom.empty`. Prefer using this one rather than creating many empty atoms using `Atom.new`.
@private
- EmptyBinary
The canonical empty `Binary`. Returned by `Binary[]` when invoked with no arguments; also returned by `Binary.empty`. Prefer using this one rather than creating many empty binaries using `Binary.new`.
@private
- EmptyMap
The canonical empty `Map`. Returned by `Map[]` when invoked with no arguments; also returned by `Map.empty`. Prefer using this one rather than creating many empty hashes using `Map.new`.
@private
- EmptyString
The canonical empty `Erlang::String`. Returned by `Erlang::String[]` when invoked with no arguments; also returned by `Erlang::String.empty`. Prefer using this one rather than creating many empty strings using `Erlang::String.new`.
@private
- EmptyTrie
@private
- EmptyTuple
The canonical empty `Tuple`. Returned by `Tuple[]` when invoked with no arguments; also returned by `Tuple.empty`. Prefer using this one rather than creating many empty tuples using `Tuple.new`.
@private
- FalseAtom
@private
- NegativeInfinity
- Nil
A list without any elements. This is a singleton, since all empty lists are equivalent.
- NilAtom
@private
- PositiveInfinity
- TrueAtom
@private
Public Class Methods
# File lib/erlang/terms.rb, line 55 def self.compare(a, b) a = Erlang.from(a) b = Erlang.from(b) t = type(a) c = Erlang::Terms::TERM_ORDER[t] <=> Erlang::Terms::TERM_ORDER[type(b)] return c if c != 0 case t when :atom return Erlang::Atom.compare(a, b) when :bitstring return Erlang::Bitstring.compare(a, b) when :fun return Erlang::Function.compare(a, b) when :list return Erlang::List.compare(a, b) when :map return Erlang::Map.compare(a, b) when :nil return 0 when :number if is_float(a) or is_float(b) af = a if not is_float(a) begin af = Erlang::Float[a] rescue ArgumentError af = a end end bf = b if not is_float(b) begin bf = Erlang::Float[b] rescue ArgumentError bf = b end end return Erlang::Float.compare(af, bf) if af.kind_of?(Erlang::Float) and bf.kind_of?(Erlang::Float) return af.data <=> bf if af.kind_of?(Erlang::Float) and not bf.kind_of?(Erlang::Float) afbfcmp = bf.data <=> af return -afbfcmp end return a <=> b when :pid return Erlang::Pid.compare(a, b) when :port return Erlang::Port.compare(a, b) when :reference return Erlang::Reference.compare(a, b) when :tuple return Erlang::Tuple.compare(a, b) else raise NotImplementedError end end
# File lib/erlang/terms.rb, line 111 def self.from(term) return term.to_erlang if term.respond_to?(:to_erlang) # integer return term if is_integer(term) # float return term if term.kind_of?(Erlang::Float) return Erlang::Float[term] if is_float(term) # atom return term if term.kind_of?(Erlang::Atom) return Erlang::Atom[term] if term.kind_of?(::Symbol) return Erlang::Atom[term] if term.kind_of?(::FalseClass) return Erlang::Atom[term] if term.kind_of?(::NilClass) return Erlang::Atom[term] if term.kind_of?(::TrueClass) # reference, function, port, pid, and tuple return term if is_reference(term) return term if is_function(term) return term if is_port(term) return term if is_pid(term) return term if is_tuple(term) # map return term if term.kind_of?(Erlang::Map) return Erlang::Map[term] if term.kind_of?(::Hash) # nil return term if term.equal?(Erlang::Nil) return Erlang::Nil if is_list(term) and term.empty? # list return term if term.kind_of?(Erlang::List) return term if term.kind_of?(Erlang::String) return Erlang::List.from_enum(term) if term.kind_of?(::Array) # bitstring return term if term.kind_of?(Erlang::Binary) return term if term.kind_of?(Erlang::Bitstring) return Erlang::Binary[term] if term.kind_of?(::String) raise ArgumentError, "unable to convert ruby object of class #{term.class} to erlang term" end
# File lib/erlang/terms.rb, line 147 def self.inspect(term = Erlang::Undefined, raw: false) return super() if Erlang::Undefined.equal?(term) term = from(term) return term.erlang_inspect(raw) if term.respond_to?(:erlang_inspect) return term.inspect if is_any(term) raise NotImplementedError end
# File lib/erlang/terms.rb, line 155 def self.iolist_to_binary(iolist) return iolist if is_binary(iolist) return Erlang::Binary.new(iolist) if iolist.is_a?(::String) return Erlang::Binary.new(iolist.to_s) if iolist.is_a?(::Symbol) if is_list(iolist) return Erlang::Binary.new(iolist.flatten.map do |element| data = nil if element.is_a?(::Integer) and element <= 255 and element >= -256 element = element + 256 if element < 0 data = element.chr elsif element.is_a?(::String) data = element elsif is_binary(element) data = element.data elsif element.is_a?(::Symbol) data = element.to_s elsif is_list(element) data = iolist_to_binary(element).data else raise ArgumentError, "unknown element in iolist: #{element.inspect}" end next Erlang::Terms.binary_encoding(data) end.join) else raise ArgumentError, "unrecognized iolist: #{iolist.inspect}" end end
# File lib/erlang/terms.rb, line 183 def self.is_any(term) return true if is_atom(term) return true if is_bitstring(term) return true if is_boolean(term) return true if is_float(term) return true if is_function(term) return true if is_integer(term) return true if is_list(term) return true if is_map(term) return true if is_number(term) return true if is_pid(term) return true if is_port(term) return true if is_reference(term) return true if is_tuple(term) return false end
# File lib/erlang/terms.rb, line 200 def self.is_atom(term) return true if term.kind_of?(::Symbol) return true if term.kind_of?(::FalseClass) return true if term.kind_of?(::NilClass) return true if term.kind_of?(::TrueClass) return true if term.kind_of?(Erlang::Atom) return false end
# File lib/erlang/terms.rb, line 209 def self.is_binary(term) return true if term.kind_of?(::String) return true if term.kind_of?(Erlang::Binary) return false end
# File lib/erlang/terms.rb, line 215 def self.is_bitstring(term) return true if is_binary(term) return true if term.kind_of?(Erlang::Bitstring) return false end
# File lib/erlang/terms.rb, line 221 def self.is_boolean(term) return true if term.kind_of?(::FalseClass) return true if term.kind_of?(::TrueClass) return true if term == :true return true if term == :false return false end
# File lib/erlang/terms.rb, line 229 def self.is_float(term) return true if term.kind_of?(::BigDecimal) return true if term.kind_of?(::Float) return true if term.kind_of?(::Rational) return true if term.kind_of?(Erlang::Float) return false end
# File lib/erlang/terms.rb, line 237 def self.is_function(term, arity = nil) if arity == nil return true if term.kind_of?(Erlang::Export) return true if term.kind_of?(Erlang::Function) else return true if is_function(term) and term.arity == arity end return false end
# File lib/erlang/terms.rb, line 247 def self.is_integer(term) return true if term.kind_of?(::Integer) return false end
# File lib/erlang/terms.rb, line 252 def self.is_list(term) return true if term.kind_of?(Erlang::List) return true if term.kind_of?(Erlang::String) return true if term.kind_of?(::Array) return true if term.equal?(Erlang::Nil) return false end
# File lib/erlang/terms.rb, line 260 def self.is_map(term) return true if term.kind_of?(Erlang::Map) return true if term.kind_of?(::Hash) return false end
# File lib/erlang/terms.rb, line 266 def self.is_number(term) return true if is_float(term) or is_integer(term) return false end
# File lib/erlang/terms.rb, line 271 def self.is_pid(term) return true if term.kind_of?(Erlang::Pid) return false end
# File lib/erlang/terms.rb, line 276 def self.is_port(term) return true if term.kind_of?(Erlang::Port) return false end
# File lib/erlang/terms.rb, line 281 def self.is_reference(term) return true if term.kind_of?(Erlang::Reference) return false end
# File lib/erlang/terms.rb, line 286 def self.is_tuple(term) return true if term.kind_of?(Erlang::Tuple) return false end
# File lib/erlang/terms.rb, line 291 def self.type(term) return :atom if is_atom(term) return :bitstring if is_bitstring(term) return :fun if is_function(term) return :list if is_list(term) and not term.empty? return :map if is_map(term) return :nil if is_list(term) and term.empty? return :number if is_number(term) return :pid if is_pid(term) return :port if is_port(term) return :reference if is_reference(term) return :tuple if is_tuple(term) raise NotImplementedError end