SYMBOL INDEX (305 symbols across 31 files)

FILE: benchmarks/builder.rb
  function regular (line 7) | def regular
  function builder (line 14) | def builder

FILE: benchmarks/setup.rb
  function profile (line 10) | def profile(&block)

FILE: lib/dry/logic.rb
  type Dry (line 6) | module Dry
    type Logic (line 7) | module Logic
      function loader (line 10) | def self.loader

FILE: lib/dry/logic/appliable.rb
  type Dry (line 3) | module Dry
    type Logic (line 4) | module Logic
      type Appliable (line 5) | module Appliable
        function id (line 6) | def id
        function result (line 10) | def result
        function applied? (line 14) | def applied?
        function success? (line 18) | def success?
        function failure? (line 22) | def failure?
        function to_ast (line 26) | def to_ast

FILE: lib/dry/logic/builder.rb
  type Dry (line 6) | module Dry
    type Logic (line 7) | module Logic
      type Builder (line 8) | module Builder
        function call (line 31) | def call(&)
        class Context (line 38) | class Context
          type Predicates (line 42) | module Predicates
          method call (line 47) | def call(&)
          method predicate (line 55) | def predicate(name, context = nil, &block)
          method initialize (line 68) | def initialize

FILE: lib/dry/logic/evaluator.rb
  type Dry (line 3) | module Dry
    type Logic (line 4) | module Logic
      class Evaluator (line 5) | class Evaluator
        class Set (line 10) | class Set
          method new (line 15) | def self.new(paths)
          method initialize (line 19) | def initialize(evaluators)
          method call (line 23) | def call(input)
        class Key (line 29) | class Key < Evaluator
          method call (line 30) | def call(input)
        class Attr (line 36) | class Attr < Evaluator
          method call (line 37) | def call(input)
        method initialize (line 43) | def initialize(path)

FILE: lib/dry/logic/operations/abstract.rb
  type Dry (line 3) | module Dry
    type Logic (line 4) | module Logic
      type Operations (line 5) | module Operations
        class Abstract (line 6) | class Abstract
          method initialize (line 15) | def initialize(*rules, **options)
          method id (line 20) | def id
          method curry (line 24) | def curry(*args)
          method new (line 28) | def new(rules, **new_options)
          method with (line 32) | def with(new_options)
          method to_ast (line 36) | def to_ast

FILE: lib/dry/logic/operations/and.rb
  type Dry (line 3) | module Dry
    type Logic (line 4) | module Logic
      type Operations (line 5) | module Operations
        class And (line 6) | class And < Binary
          method initialize (line 9) | def initialize(*, **)
          method type (line 14) | def type
          method call (line 19) | def call(input)
          method [] (line 38) | def [](input)

FILE: lib/dry/logic/operations/attr.rb
  type Dry (line 3) | module Dry
    type Logic (line 4) | module Logic
      type Operations (line 5) | module Operations
        class Attr (line 6) | class Attr < Key
          method evaluator (line 7) | def self.evaluator(name)
          method type (line 11) | def type

FILE: lib/dry/logic/operations/binary.rb
  type Dry (line 3) | module Dry
    type Logic (line 4) | module Logic
      type Operations (line 5) | module Operations
        class Binary (line 6) | class Binary < Abstract
          method initialize (line 11) | def initialize(left, right, **options)
          method ast (line 17) | def ast(input = Undefined)
          method to_s (line 21) | def to_s

FILE: lib/dry/logic/operations/check.rb
  type Dry (line 3) | module Dry
    type Logic (line 4) | module Logic
      type Operations (line 5) | module Operations
        class Check (line 6) | class Check < Unary
          method new (line 9) | def self.new(rule, **options)
          method initialize (line 20) | def initialize(*rules, **options)
          method type (line 25) | def type
          method call (line 29) | def call(input)
          method [] (line 40) | def [](input)
          method ast (line 44) | def ast(input = Undefined)

FILE: lib/dry/logic/operations/each.rb
  type Dry (line 3) | module Dry
    type Logic (line 4) | module Logic
      type Operations (line 5) | module Operations
        class Each (line 6) | class Each < Unary
          method type (line 7) | def type
          method call (line 11) | def call(input)
          method [] (line 25) | def [](arr)

FILE: lib/dry/logic/operations/implication.rb
  type Dry (line 3) | module Dry
    type Logic (line 4) | module Logic
      type Operations (line 5) | module Operations
        class Implication (line 6) | class Implication < Binary
          method type (line 7) | def type
          method operator (line 11) | def operator
          method call (line 15) | def call(input)
          method [] (line 26) | def [](input)

FILE: lib/dry/logic/operations/key.rb
  type Dry (line 3) | module Dry
    type Logic (line 4) | module Logic
      type Operations (line 5) | module Operations
        class Key (line 6) | class Key < Unary
          method new (line 11) | def self.new(rules, **options)
          method evaluator (line 21) | def self.evaluator(name)
          method initialize (line 25) | def initialize(*rules, **options)
          method type (line 31) | def type
          method call (line 35) | def call(hash)
          method [] (line 46) | def [](hash)
          method ast (line 50) | def ast(input = Undefined)
          method to_s (line 58) | def to_s

FILE: lib/dry/logic/operations/negation.rb
  type Dry (line 3) | module Dry
    type Logic (line 4) | module Logic
      type Operations (line 5) | module Operations
        class Negation (line 6) | class Negation < Unary
          method type (line 7) | def type
          method call (line 11) | def call(input)
          method [] (line 15) | def [](input)

FILE: lib/dry/logic/operations/or.rb
  type Dry (line 3) | module Dry
    type Logic (line 4) | module Logic
      type Operations (line 5) | module Operations
        class Or (line 6) | class Or < Binary
          method type (line 7) | def type
          method call (line 12) | def call(input)
          method [] (line 28) | def [](input)

FILE: lib/dry/logic/operations/set.rb
  type Dry (line 3) | module Dry
    type Logic (line 4) | module Logic
      type Operations (line 5) | module Operations
        class Set (line 6) | class Set < Abstract
          method type (line 7) | def type
          method call (line 11) | def call(input)
          method [] (line 20) | def [](input)
          method ast (line 24) | def ast(input = Undefined)
          method to_s (line 28) | def to_s

FILE: lib/dry/logic/operations/unary.rb
  type Dry (line 3) | module Dry
    type Logic (line 4) | module Logic
      type Operations (line 5) | module Operations
        class Unary (line 6) | class Unary < Abstract
          method initialize (line 9) | def initialize(*rules, **options)
          method ast (line 14) | def ast(input = Undefined)
          method to_s (line 18) | def to_s

FILE: lib/dry/logic/operations/xor.rb
  type Dry (line 3) | module Dry
    type Logic (line 4) | module Logic
      type Operations (line 5) | module Operations
        class Xor (line 6) | class Xor < Binary
          method type (line 7) | def type
          method call (line 12) | def call(input)
          method [] (line 16) | def [](input)
          method ast (line 20) | def ast(input = Undefined)

FILE: lib/dry/logic/operators.rb
  type Dry (line 3) | module Dry
    type Logic (line 4) | module Logic
      type Operators (line 5) | module Operators
        function and (line 6) | def and(other)
        function or (line 11) | def or(other)
        function xor (line 16) | def xor(other)
        function then (line 21) | def then(other)

FILE: lib/dry/logic/predicates.rb
  type Dry (line 10) | module Dry
    type Logic (line 11) | module Logic
      type Predicates (line 12) | module Predicates
        type Methods (line 15) | module Methods
          function uuid_format (line 16) | def self.uuid_format(version)
          function [] (line 38) | def [](name)
          function type? (line 42) | def type?(type, input) = input.is_a?(type)
          function nil? (line 44) | def nil?(input) = input.nil?
          function key? (line 47) | def key?(name, input) = input.key?(name)
          function attr? (line 49) | def attr?(name, input) = input.respond_to?(name)
          function empty? (line 51) | def empty?(input)
          function filled? (line 60) | def filled?(input) = !empty?(input)
          function bool? (line 62) | def bool?(input) = input.equal?(true) || input.equal?(false)
          function date? (line 64) | def date?(input) = input.is_a?(::Date)
          function date_time? (line 66) | def date_time?(input) = input.is_a?(::DateTime)
          function time? (line 68) | def time?(input) = input.is_a?(::Time)
          function number? (line 70) | def number?(input)
          function int? (line 76) | def int?(input) = input.is_a?(::Integer)
          function float? (line 78) | def float?(input) = input.is_a?(::Float)
          function decimal? (line 80) | def decimal?(input) = input.is_a?(::BigDecimal)
          function str? (line 82) | def str?(input) = input.is_a?(::String)
          function hash? (line 84) | def hash?(input) = input.is_a?(::Hash)
          function array? (line 86) | def array?(input) = input.is_a?(::Array)
          function odd? (line 88) | def odd?(input) = input.odd?
          function even? (line 90) | def even?(input) = input.even?
          function lt? (line 92) | def lt?(num, input) = input < num
          function gt? (line 94) | def gt?(num, input) = input > num
          function lteq? (line 96) | def lteq?(num, input) = !gt?(num, input)
          function gteq? (line 98) | def gteq?(num, input) = !lt?(num, input)
          function size? (line 100) | def size?(size, input)
          function min_size? (line 109) | def min_size?(num, input) = input.size >= num
          function max_size? (line 111) | def max_size?(num, input) = input.size <= num
          function bytesize? (line 113) | def bytesize?(size, input)
          function min_bytesize? (line 122) | def min_bytesize?(num, input) = input.bytesize >= num
          function max_bytesize? (line 124) | def max_bytesize?(num, input) = input.bytesize <= num
          function inclusion? (line 126) | def inclusion?(list, input)
          function exclusion? (line 131) | def exclusion?(list, input)
          function included_in? (line 136) | def included_in?(list, input) = list.include?(input)
          function excluded_from? (line 138) | def excluded_from?(list, input) = !list.include?(input)
          function includes? (line 140) | def includes?(value, input)
          function excludes? (line 150) | def excludes?(value, input) = !includes?(value, input)
          function eql? (line 153) | def eql?(left, right = Undefined)
          function is? (line 159) | def is?(left, right) = left.equal?(right)
          function not_eql? (line 161) | def not_eql?(left, right) = !left.eql?(right)
          function true? (line 163) | def true?(value) = value.equal?(true)
          function false? (line 165) | def false?(value) = value.equal?(false)
          function format? (line 167) | def format?(regex, input) = !input.nil? && regex.match?(input)
          function case? (line 169) | def case?(pattern, input) = pattern === input
          function uuid_v1? (line 171) | def uuid_v1?(input) = format?(UUIDv1, input)
          function uuid_v2? (line 173) | def uuid_v2?(input) = format?(UUIDv2, input)
          function uuid_v3? (line 175) | def uuid_v3?(input) = format?(UUIDv3, input)
          function uuid_v4? (line 177) | def uuid_v4?(input) = format?(UUIDv4, input)
          function uuid_v5? (line 179) | def uuid_v5?(input) = format?(UUIDv5, input)
          function uuid_v6? (line 181) | def uuid_v6?(input) = format?(UUIDv6, input)
          function uuid_v7? (line 183) | def uuid_v7?(input) = format?(UUIDv7, input)
          function uuid_v8? (line 185) | def uuid_v8?(input) = format?(UUIDv8, input)
          function uri? (line 188) | def uri?(schemes, input)
          function uri? (line 193) | def uri?(schemes, input)
          function uri_rfc3986? (line 199) | def uri_rfc3986?(input) = format?(::URI::RFC3986_Parser::RFC3986...
          function respond_to? (line 202) | def respond_to?(method, input = Undefined)
          function predicate (line 208) | def predicate(name, &)
          function deprecated (line 212) | def deprecated(name, in_favor_of)
        function included (line 225) | def self.included(other)

FILE: lib/dry/logic/result.rb
  type Dry (line 3) | module Dry
    type Logic (line 4) | module Logic
      class Result (line 5) | class Result
        method success? (line 7) | def success?
        method failure? (line 11) | def failure?
        method initialize (line 22) | def initialize(success, id = nil, &block)
        method success? (line 28) | def success?
        method failure? (line 32) | def failure?
        method type (line 36) | def type
        method ast (line 40) | def ast(input = Undefined)
        method to_ast (line 44) | def to_ast
        method to_s (line 52) | def to_s
        method visit (line 58) | def visit(ast)
        method visit_predicate (line 62) | def visit_predicate(node)
        method visit_and (line 72) | def visit_and(node)
        method visit_or (line 77) | def visit_or(node)
        method visit_xor (line 82) | def visit_xor(node)
        method visit_not (line 87) | def visit_not(node)
        method visit_hint (line 91) | def visit_hint(node)

FILE: lib/dry/logic/rule.rb
  type Dry (line 5) | module Dry
    type Logic (line 6) | module Logic
      function Rule (line 7) | def self.Rule(*args, **options, &block)
        method interfaces (line 28) | def self.interfaces
        method specialize (line 32) | def self.specialize(arity, curried, base = Rule)
        method build (line 41) | def self.build(predicate, args: EMPTY_ARRAY, arity: predicate.arit...
        method initialize (line 45) | def initialize(predicate, options = EMPTY_HASH)
        method type (line 52) | def type
        method id (line 56) | def id
        method curry (line 60) | def curry(*new_args)
        method bind (line 64) | def bind(object)
        method eval_args (line 75) | def eval_args(object)
        method with (line 79) | def with(new_opts)
        method parameters (line 83) | def parameters
        method ast (line 87) | def ast(input = Undefined)
        method args_with_names (line 93) | def args_with_names(*input)
      class Rule (line 15) | class Rule
        method interfaces (line 28) | def self.interfaces
        method specialize (line 32) | def self.specialize(arity, curried, base = Rule)
        method build (line 41) | def self.build(predicate, args: EMPTY_ARRAY, arity: predicate.arit...
        method initialize (line 45) | def initialize(predicate, options = EMPTY_HASH)
        method type (line 52) | def type
        method id (line 56) | def id
        method curry (line 60) | def curry(*new_args)
        method bind (line 64) | def bind(object)
        method eval_args (line 75) | def eval_args(object)
        method with (line 79) | def with(new_opts)
        method parameters (line 83) | def parameters
        method ast (line 87) | def ast(input = Undefined)
        method args_with_names (line 93) | def args_with_names(*input)

FILE: lib/dry/logic/rule/interface.rb
  type Dry (line 3) | module Dry
    type Logic (line 4) | module Logic
      class Rule (line 5) | class Rule
        class Interface (line 6) | class Interface < ::Module
          method initialize (line 13) | def initialize(arity, curried)
          method constant? (line 32) | def constant? = arity.zero?
          method variable_arity? (line 34) | def variable_arity? = arity.negative?
          method curried? (line 36) | def curried? = !curried.zero?
          method unapplied (line 38) | def unapplied
          method name (line 52) | def name
          method define_constructor (line 74) | def define_constructor
          method define_constant_application (line 91) | def define_constant_application
          method define_application (line 107) | def define_application
          method curried_args (line 127) | def curried_args
          method unapplied_args (line 131) | def unapplied_args

FILE: lib/dry/logic/rule/predicate.rb
  type Dry (line 3) | module Dry
    type Logic (line 4) | module Logic
      class Rule (line 5) | class Rule
        class Predicate (line 6) | class Predicate < Rule
          method specialize (line 7) | def self.specialize(arity, curried, base = Predicate)
          method type (line 11) | def type
          method name (line 15) | def name
          method to_s (line 19) | def to_s
          method ast (line 27) | def ast(input = Undefined)

FILE: lib/dry/logic/rule_compiler.rb
  type Dry (line 3) | module Dry
    type Logic (line 4) | module Logic
      class RuleCompiler (line 5) | class RuleCompiler
        method initialize (line 8) | def initialize(predicates)
        method call (line 12) | def call(ast)
        method visit (line 16) | def visit(node)
        method visit_check (line 21) | def visit_check(node)
        method visit_not (line 26) | def visit_not(node)
        method visit_key (line 30) | def visit_key(node)
        method visit_attr (line 35) | def visit_attr(node)
        method visit_set (line 40) | def visit_set(node)
        method visit_each (line 44) | def visit_each(node)
        method visit_predicate (line 48) | def visit_predicate(node)
        method visit_and (line 60) | def visit_and(node)
        method visit_or (line 65) | def visit_or(node)
        method visit_xor (line 70) | def visit_xor(node)
        method visit_implication (line 75) | def visit_implication(node)

FILE: lib/dry/logic/version.rb
  type Dry (line 3) | module Dry
    type Logic (line 4) | module Logic

FILE: spec/spec_helper.rb
  function undefined (line 21) | def undefined

FILE: spec/support/mutant.rb
  type Mutant (line 3) | module Mutant
    class Selector (line 4) | class Selector
      class Expression (line 5) | class Expression < self
        method call (line 6) | def call(_subject)

FILE: spec/unit/rule/predicate_spec.rb
  function test? (line 44) | def self.test?

FILE: spec/unit/rule_spec.rb
  function respond_to_missing? (line 13) | def respond_to_missing?(m, *)
  function method_missing (line 17) | def method_missing(m, *)
  function to_proc (line 25) | def to_proc
  function arity (line 29) | def arity
  function parameters (line 33) | def parameters
  function test? (line 84) | def test?
  function expected (line 104) | def expected
  function num (line 144) | def num