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:



2190
2191
2192
2193
2194
 
# File 'lib/puppet/pops/types/types.rb', line 2190

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:



2185
2186
2187
 
# File 'lib/puppet/pops/types/types.rb', line 2185

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



2179
2180
2181
 
# File 'lib/puppet/pops/types/types.rb', line 2179

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



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

def return_type
  @return_type
end

Class Method Details

.register_ptype(loader, ir) ⇒ Object 



2157
2158
2159
2160
2161
2162
2163
2164
2165
2166
2167
2168
2169
2170
2171
2172
 
# File 'lib/puppet/pops/types/types.rb', line 2157

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 



2196
2197
2198
2199
2200
2201
 
# File 'lib/puppet/pops/types/types.rb', line 2196

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



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

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) 


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

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



2233
2234
2235
2236
2237
2238
2239
2240
2241
2242
 
# File 'lib/puppet/pops/types/types.rb', line 2233

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) 


2282
2283
2284
 
# File 'lib/puppet/pops/types/types.rb', line 2282

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 



2203
2204
2205
2206
2207
2208
2209
2210
2211
2212
 
# File 'lib/puppet/pops/types/types.rb', line 2203

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 



2278
2279
2280
 
# File 'lib/puppet/pops/types/types.rb', line 2278

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

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

Returns:

  • (Boolean) 


2225
2226
2227
 
# File 'lib/puppet/pops/types/types.rb', line 2225

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) 


2250
2251
2252
 
# File 'lib/puppet/pops/types/types.rb', line 2250

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]



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

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

#normalize(guard = nil) ⇒ Object 



2214
2215
2216
2217
2218
2219
2220
2221
2222
2223
 
# File 'lib/puppet/pops/types/types.rb', line 2214

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 



2286
2287
2288
2289
2290
2291
 
# File 'lib/puppet/pops/types/types.rb', line 2286

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]



2255
2256
2257
 
# File 'lib/puppet/pops/types/types.rb', line 2255

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