add a Case block to the expression

@param ca   the object for switch-expression to match
@param func function to apply when matches and return a result for
expression to return
@return <code>this</code>
430378
public SwitchBlock<T, R> Case(T ca, RFunc0<R> func) {
                return Case(ca, $(func));
        }
848604
@Nonnull
	public <V1 extends T1, V2 extends T2> LObjIntObjPredicateBuilder<T1, T2> aCase(Class<V1> argC1, Class<V2> argC3, LObjIntObjPredicate<V1, V2> function) {
		PartialCaseWithBoolProduct.The pc = partialCaseFactoryMethod((a1, a2, a3) -> (argC1 == null || argC1.isInstance(a1)) && (argC3 == null || argC3.isInstance(a2)));

		pc.evaluate(function);
		return self();
	}
1104994
public SwitchBuilder addCase(ImmutableList<Expression> caseLabels, Statement body) {
    Preconditions.checkState(!caseLabels.isEmpty(), "at least one case required");
    clauses.add(new Switch.CaseClause(caseLabels, body));
    return this;
  }
70067
@Nonnull
	public <V1 extends T1, V2 extends T2> LToByteBiFunctionBuilder<T1, T2> aCase(Class<V1> argC1, Class<V2> argC2, LToByteBiFunction<V1, V2> function) {
		PartialCaseWithByteProduct.The pc = partialCaseFactoryMethod((a1, a2) -> (argC1 == null || argC1.isInstance(a1)) && (argC2 == null || argC2.isInstance(a2)));

		pc.evaluate(function);
		return self();
	}
429216
public CaseForEqBuilder<T> when(T other) {
        return new CaseForEqBuilder<T>(mixin, ConstantImpl.create(other));
    }
1358930
public static <F, T, KeyT extends F, TestT extends F>
  Function<EvalPair<? extends KeyT, ? extends TestT>, EvalPair<T, T>> functionOnBoth(
      final Function<F, T> func) {
    return new Function<EvalPair<? extends KeyT, ? extends TestT>, EvalPair<T, T>>() {
      @Override
      public EvalPair<T, T> apply(final EvalPair<? extends KeyT, ? extends TestT> input) {
        return EvalPair.of(func.apply(input.key()), func.apply(input.test()));
      }

      @Override
      public String toString() {
        return "EvalPair.functionOnBoth(" + func + ")";
      }
    };
  }
632293
@Nonnull
	public <V extends T> LConsumerBuilder<T> casesOf(Class<V> argC, Consumer<LConsumerBuilder<V>> pcpConsumer) {
		PartialCase.The pc = partialCaseFactoryMethod(a -> (argC == null || argC.isInstance(a)));

		pc.specifySubCases((Consumer) pcpConsumer);
		return self();
	}
1296512
@Nonnull
	public <V1 extends T1, V2 extends T2> LToFltBiFunctionBuilder<T1, T2> aCase(Class<V1> argC1, Class<V2> argC2, LToFltBiFunction<V1, V2> function) {
		PartialCaseWithFltProduct.The pc = partialCaseFactoryMethod((a1, a2) -> (argC1 == null || argC1.isInstance(a1)) && (argC2 == null || argC2.isInstance(a2)));

		pc.evaluate(function);
		return self();
	}
433052
public T Else(def<T> func) {
                if (procceed)
                        if (initVal != null && !initVal.equals(false)) {
                                return body.apply(initVal);
                        } else {
                                return func.apply();
                        }
                else
                        return this.val;
        }
1312329
public <R> AnimaQuery<T> and(TypeFunction<T, R> function, Object value) {
        return this.where(function, value);
    }
824842
@Nonnull
	public <V1 extends T1, V2 extends T2, V3 extends T3> LToIntTriFunctionBuilder<T1, T2, T3> aCase(Class<V1> argC1, Class<V2> argC2, Class<V3> argC3, LToIntTriFunction<V1, V2, V3> function) {
		PartialCaseWithIntProduct.The pc = partialCaseFactoryMethod((a1, a2, a3) -> (argC1 == null || argC1.isInstance(a1)) && (argC2 == null || argC2.isInstance(a2)) && (argC3 == null || argC3.isInstance(a3)));

		pc.evaluate(function);
		return self();
	}
1328123
@Nonnull
	public <V extends T> LToFltFunctionBuilder<T> aCase(Class<V> argC, LToFltFunction<V> function) {
		PartialCaseWithFltProduct.The pc = partialCaseFactoryMethod(a -> (argC == null || argC.isInstance(a)));

		pc.evaluate(function);
		return self();
	}
333241
function addTypeFunction (typeName, funcName, func) {
  if (!stringValue(typeName)) {
    throw new Error('Invalid "typeName" argument, must be String')
  } else if (!_.isFunction(func) && !stringValue(func)) {
    throw new Error('Invalid func argument, must be function')
  }
  _.set(this.backing, [ typeName, `_${funcName}` ], func)
  return this
}
1238907
public function map(callable $func = null): self
    {
        if (null === $func) {
            return $this;
        }

        return parent::map($func);
    }
1344937
public function setFunc($func)
    {
        if ($func === null) {
            $this->func = $func;
            return $this;
        }

        if (!is_string($func)) {
            throw new InvalidArgumentException(
                'Function name should be a string.'
            );
        }

        $func = strtoupper($func);
        if (!in_array($func, $this->validFunc())) {
            throw new InvalidArgumentException(sprintf(
                'Function "%s" not allowed in this context.',
                $func
            ));
        }

        $this->func = $func;
        return $this;
    }
1299757
public final PCB evaluate(@Nonnull F caseFunction) {
        PCB superContext = superContext();
        superContext.aCase(Case.of(casePredicate, caseFunction));
        return superContext;
    }
515434
@SuppressWarnings("unchecked")
  public T queue(Function... funcs) {
    for (Element e : elements()) {
      for (Function f : funcs) {
        queue(e, DEFAULT_NAME, f);
      }
    }
    return (T) this;
  }