Class: Puppet::Pops::Types::PCallableType

Inherits:
PAnyType show all
Defined in:
lib/puppet/pops/types/types.rb

Constant Summary collapse

DEFAULT = 
PCallableType.new(nil, nil, nil)

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Methods inherited from PAnyType

#==, #assignable?, #callable?, #check_self_recursion, #create, #iterable?, #iterable_type, #name, new_function, #new_function, #really_instance?, #simple_name, simple_name, #to_alias_expanded_s, #to_s

Methods inherited from TypedModelObject

_ptype, create_ptype, register_ptypes

Methods included from PuppetObject

#_ptype

Constructor Details

#initialize(param_types, block_type = nil, return_type = nil) ⇒ PCallableType

Returns a new instance of PCallableType.

Parameters:



2174
2175
2176
2177
2178
 
# File 'lib/puppet/pops/types/types.rb', line 2174

def initialize(param_types, block_type = nil, return_type = nil)
  @param_types = param_types
  @block_type = block_type
  @return_type = return_type == PAnyType::DEFAULT ? nil : return_type
end

Instance Attribute Details

#block_type ⇒ PAnyType|nil (readonly)

Although being an abstract type reference, only Callable, or all Callables wrapped in Optional or Variant are supported If not set, the meaning is that block is not supported.

Returns:



2169
2170
2171
 
# File 'lib/puppet/pops/types/types.rb', line 2169

def block_type
  @block_type
end

#param_types ⇒ PTupleType (readonly)

Types of parameters as a Tuple with required/optional count, or an Integer with min (required), max count

Returns:

  • (PTupleType) —

    the tuple representing the parameter types



2163
2164
2165
 
# File 'lib/puppet/pops/types/types.rb', line 2163

def param_types
  @param_types
end

#return_type ⇒ PAnyType (readonly)

Returns The type for the values returned by this callable. Returns ‘nil` if return value is unconstrained.

Returns:

  • (PAnyType) —

    The type for the values returned by this callable. Returns ‘nil` if return value is unconstrained



2159
2160
2161
 
# File 'lib/puppet/pops/types/types.rb', line 2159

def return_type
  @return_type
end

Class Method Details

.register_ptype(loader, ir) ⇒ Object 



2141
2142
2143
2144
2145
2146
2147
2148
2149
2150
2151
2152
2153
2154
2155
2156
 
# File 'lib/puppet/pops/types/types.rb', line 2141

def self.register_ptype(loader, ir)
  create_ptype(loader, ir, 'AnyType',
    'param_types' => {
      KEY_TYPE => POptionalType.new(PTupleType::DEFAULT),
      KEY_VALUE => nil
    },
    'block_type' => {
      KEY_TYPE => POptionalType.new(PCallableType::DEFAULT),
      KEY_VALUE => nil
    },
    'return_type' => {
      KEY_TYPE => POptionalType.new(PType::DEFAULT),
      KEY_VALUE => PAnyType::DEFAULT
    }
  )
end

Instance Method Details

#accept(visitor, guard) ⇒ Object 



2180
2181
2182
2183
2184
2185
 
# File 'lib/puppet/pops/types/types.rb', line 2180

def accept(visitor, guard)
  super
  @param_types.accept(visitor, guard) unless @param_types.nil?
  @block_type.accept(visitor, guard) unless @block_type.nil?
  @return_type.accept(visitor, guard) unless @return_type.nil?
end

#block_range ⇒ Object

Range [0,0], [0,1], or [1,1] for the block



2251
2252
2253
2254
2255
2256
2257
2258
2259
2260
 
# File 'lib/puppet/pops/types/types.rb', line 2251

def block_range
  case block_type
  when POptionalType
    [0,1]
  when PVariantType, PCallableType
    [1,1]
  else
    [0,0]
  end
end

#callable_args?(required_callable_t, guard) ⇒ Boolean

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Returns:

  • (Boolean) 


2229
2230
2231
2232
 
# File 'lib/puppet/pops/types/types.rb', line 2229

def callable_args?(required_callable_t, guard)
  # If the required callable is euqal or more specific than self, self is acceptable arguments
  required_callable_t.assignable?(self, guard)
end

#callable_with?(args, block = nil) ⇒ Boolean

Returns ‘true` if this instance is a callable that accepts the given args

Parameters:

  • args (Array) —

    the arguments to test

Returns:

  • (Boolean) —

    ‘true` if this instance is a callable that accepts the given args



2217
2218
2219
2220
2221
2222
2223
2224
2225
2226
 
# File 'lib/puppet/pops/types/types.rb', line 2217

def callable_with?(args, block = nil)
  # nil param_types and compatible return type means other Callable is assignable
  return true if @param_types.nil?
  return false unless @param_types.instance?(args)
  if @block_type.nil?
    block == nil
  else
    @block_type.instance?(block)
  end
end

#eql?(o) ⇒ Boolean

Returns:

  • (Boolean) 


2266
2267
2268
 
# File 'lib/puppet/pops/types/types.rb', line 2266

def eql?(o)
  self.class == o.class && @param_types == o.param_types && @block_type == o.block_type && @return_type == o.return_type
end

#generalize ⇒ Object 



2187
2188
2189
2190
2191
2192
2193
2194
2195
2196
 
# File 'lib/puppet/pops/types/types.rb', line 2187

def generalize
  if self == DEFAULT
    DEFAULT
  else
    params_t = @param_types.nil? ? nil : @param_types.generalize
    block_t = @block_type.nil? ? nil : @block_type.generalize
    return_t = @return_type.nil? ? nil : @return_type.generalize
    @param_types.equal?(params_t) && @block_type.equal?(block_t) && @return_type.equal?(return_t) ? self : PCallableType.new(params_t, block_t, return_t)
  end
end

#hash ⇒ Object 



2262
2263
2264
 
# File 'lib/puppet/pops/types/types.rb', line 2262

def hash
  [@param_types, @block_type, @return_type].hash
end

#instance?(o, guard = nil) ⇒ Boolean

Returns:

  • (Boolean) 


2209
2210
2211
 
# File 'lib/puppet/pops/types/types.rb', line 2209

def instance?(o, guard = nil)
  (o.is_a?(Proc) || o.is_a?(Evaluator::Closure) || o.is_a?(Functions::Function)) && assignable?(TypeCalculator.infer(o), guard)
end

#kind_of_callable?(optional = true, guard = nil) ⇒ Boolean

Returns:

  • (Boolean) 


2234
2235
2236
 
# File 'lib/puppet/pops/types/types.rb', line 2234

def kind_of_callable?(optional=true, guard = nil)
  true
end

#last_range ⇒ Object

Returns the number of accepted arguments for the last parameter type [min, max]



2245
2246
2247
 
# File 'lib/puppet/pops/types/types.rb', line 2245

def last_range
  @param_types.nil? ? nil : @param_types.repeat_last_range
end

#normalize(guard = nil) ⇒ Object 



2198
2199
2200
2201
2202
2203
2204
2205
2206
2207
 
# File 'lib/puppet/pops/types/types.rb', line 2198

def normalize(guard = nil)
  if self == DEFAULT
    DEFAULT
  else
    params_t = @param_types.nil? ? nil : @param_types.normalize(guard)
    block_t = @block_type.nil? ? nil : @block_type.normalize(guard)
    return_t = @return_type.nil? ? nil : @return_type.normalize(guard)
    @param_types.equal?(params_t) && @block_type.equal?(block_t) && @return_type.equal?(return_t) ? self : PCallableType.new(params_t, block_t, return_t)
  end
end

#resolve(type_parser, loader) ⇒ Object 



2270
2271
2272
2273
2274
2275
 
# File 'lib/puppet/pops/types/types.rb', line 2270

def resolve(type_parser, loader)
  params_t = @param_types.nil? ? nil : @param_types.resolve(type_parser, loader)
  block_t = @block_type.nil? ? nil : @block_type.resolve(type_parser, loader)
  return_t = @return_type.nil? ? nil : @return_type.resolve(type_parser, loader)
  @param_types.equal?(params_t) && @block_type.equal?(block_t) && @return_type.equal?(return_t) ? self : self.class.new(params_t, block_t, return_t)
end

#size_range ⇒ Object

Returns the number of accepted arguments [min, max]



2239
2240
2241
 
# File 'lib/puppet/pops/types/types.rb', line 2239

def size_range
  @param_types.nil? ? nil : @param_types.size_range
end