How to use com.oath.cyclops.matching

public static <T, R> Case<T, R> Case(Pattern<T> pattern1, Pattern<T> pattern2, Function<T, R> supplier) {
  return new Case.Case0<>(pattern1.and(pattern2), supplier);
}

public static <T extends Deconstruct1<T1>, T1> PatternMatching<Tuple1<T1>> Match(T value) {
  return new PatternMatching<>(value.unapply());
}

public static <T extends Deconstruct2<T1, T2>, T1, T2> PatternMatching<Tuple2<T1, T2>> Match(T value) {
  return new PatternMatching<>(value.unapply());
}

public static <T extends Deconstruct4<T1, T2, T3, T4>, T1, T2, T3, T4> PatternMatching<Tuple4<T1, T2, T3, T4>> Match(T value) {
  return new PatternMatching<>(value.unapply());
}

public static <T extends Deconstruct<T1>, T1> PatternMatching<T1> Match(T value) {
  return new PatternMatching<>(value.unapply());
}

public static <T extends Deconstruct3<T1, T2, T3>, T1, T2, T3> PatternMatching<Tuple3<T1, T2, T3>> Match(T value) {
  return new PatternMatching<>(value.unapply());
}

public static <T extends Deconstruct5<T1, T2, T3, T4, T5>, T1, T2, T3, T4, T5> PatternMatching<Tuple5<T1, T2, T3, T4, T5>> Match(T value) {
  return new PatternMatching<>(value.unapply());
}

public <R> R with(Case<T1, R> case1, Case<T2, R> case2, Case<T3, R> case3, Case<T4, R> case4, Case<T5, R> case5) {
  return value.fold(a -> case1.test(a), b -> case2.test(b), c -> case3.test(c), d -> case4.test(d), e -> case5.test(e)).orElse(null);
}

public <R> R with(Case<T1, R> case1, Case<T2, R> case2, Case<T3, R> case3, Case<T4, R> case4) {
  return value.fold(a -> case1.test(a), b -> case2.test(b), c -> case3.test(c), d -> case4.test(d)).orElse(null);
}

public <R> R with(Case<T1, R> case1, Case<T2, R> case2, Case<T3, R> case3) {
  return value.fold(a -> case1.test(a), b -> case2.test(b), c -> case3.test(c)).orElse(null);
}

public static <T, R> Case<Optional<T>, R> Case(Supplier<R> supplier0, Supplier<R> supplier1) {
  return new Case.CaseOptional<>(supplier0, supplier1);
}

public static <T, R> Case<T, R> Case(Predicate<T> predicate, Function<T, R> supplier) {
  return new Case.Case0<>(predicate, supplier);
}

public static <T1, T2, T3, T4, T5, R> Case<Tuple5<T1, T2, T3, T4, T5>, R> Case(Predicate<T1> predicate1, Predicate<T2> predicate2, Predicate<T3> predicate3, Predicate<T4> predicate4, Predicate<T5> predicate5, Function<Tuple5<T1, T2, T3, T4, T5>, R> fn) {
  return new Case.Case5<>(predicate1, predicate2, predicate3, predicate4, predicate5, fn);
}

public static <T> OptionalMatching<T> Match(final Optional<T> value) {
  return new OptionalMatching<T>(value);
}

public static <T1, T2> Matching.PatternMatching2<T1, T2> MatchType(Sealed2<T1, T2> value) {
  return new Matching.PatternMatching2<>(value);
}

public static <T1, T2, T3, T4, T5> PatternMatching5<T1, T2, T3, T4, T5> MatchType(Sealed5<T1, T2, T3, T4, T5> value) {
  return new PatternMatching5<>(value);
}

public static <T, R> Case<T, R> Case(Function<? super T, ? extends R> fn) {
  return new Case.CaseFn(fn);
}

public String dataLoader(){
 return remote.data();
}
public void dataSaver(int data){

public void dataSaver(int data){
 remote.save(data);
}
public int remoteStringLength(String data){

public static <T, R> Case<T, R> Case(Pattern<T> pattern1, Pattern<T> pattern2, Supplier<R> supplier) {
  return new Case.Case0<>(pattern1.and(pattern2), value -> supplier.get());
}