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, #create, #iterable?, #iterable_type, #loader, #name, new_function, #new_function, #really_instance?, #roundtrip_with_string?, simple_name, #simple_name, #to_alias_expanded_s, #to_s

Methods inherited from TypedModelObject

_pcore_type, create_ptype, register_ptypes

Methods included from PuppetObject

#_pcore_all_contents, #_pcore_contents, #_pcore_init_hash, #_pcore_type, #to_s

Constructor Details

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

Returns a new instance of PCallableType.

Parameters:



2388
2389
2390
2391
2392
# File 'lib/puppet/pops/types/types.rb', line 2388

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_typePAnyType|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:



2383
2384
2385
# File 'lib/puppet/pops/types/types.rb', line 2383

def block_type
  @block_type
end

#param_typesPTupleType (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



2377
2378
2379
# File 'lib/puppet/pops/types/types.rb', line 2377

def param_types
  @param_types
end

#return_typePAnyType (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



2373
2374
2375
# File 'lib/puppet/pops/types/types.rb', line 2373

def return_type
  @return_type
end

Class Method Details

.register_ptype(loader, ir) ⇒ Object



2356
2357
2358
2359
2360
2361
2362
2363
2364
2365
2366
2367
2368
2369
2370
# File 'lib/puppet/pops/types/types.rb', line 2356

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

Instance Method Details

#accept(visitor, guard) ⇒ Object



2394
2395
2396
2397
2398
2399
# File 'lib/puppet/pops/types/types.rb', line 2394

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_rangeObject

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



2466
2467
2468
2469
2470
2471
2472
2473
2474
2475
# File 'lib/puppet/pops/types/types.rb', line 2466

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)


2444
2445
2446
2447
# File 'lib/puppet/pops/types/types.rb', line 2444

def callable_args?(required_callable_t, guard)
  # If the required callable is equal 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



2431
2432
2433
2434
2435
2436
2437
2438
2439
2440
2441
# File 'lib/puppet/pops/types/types.rb', line 2431

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)


2481
2482
2483
# File 'lib/puppet/pops/types/types.rb', line 2481

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

#generalizeObject



2401
2402
2403
2404
2405
2406
2407
2408
2409
2410
# File 'lib/puppet/pops/types/types.rb', line 2401

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

#hashObject



2477
2478
2479
# File 'lib/puppet/pops/types/types.rb', line 2477

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

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

Returns:

  • (Boolean)


2423
2424
2425
# File 'lib/puppet/pops/types/types.rb', line 2423

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)


2449
2450
2451
# File 'lib/puppet/pops/types/types.rb', line 2449

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

#last_rangeObject

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



2460
2461
2462
# File 'lib/puppet/pops/types/types.rb', line 2460

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

#normalize(guard = nil) ⇒ Object



2412
2413
2414
2415
2416
2417
2418
2419
2420
2421
# File 'lib/puppet/pops/types/types.rb', line 2412

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(loader) ⇒ Object



2485
2486
2487
2488
2489
2490
# File 'lib/puppet/pops/types/types.rb', line 2485

def resolve(loader)
  params_t = @param_types.nil? ? nil : @param_types.resolve(loader)
  block_t = @block_type.nil? ? nil : @block_type.resolve(loader)
  return_t = @return_type.nil? ? nil : @return_type.resolve(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_rangeObject

Returns the number of accepted arguments [min, max]



2454
2455
2456
# File 'lib/puppet/pops/types/types.rb', line 2454

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