const anySegment = (hints: CacheControlHintsFormat): boolean => compose<CacheControlHintsFormat, MaybeCacheScope[], boolean>(
  any(equals('SEGMENT')) as any,
  pluck('scope')
)(hints)

const isStrike = rolls => equals(10, head(rolls));

import * as R from 'ramda';

const isEven = R.pipe(R.modulo(R.__, 2), R.equals(0));

function solve(
    maxValue: number,
    acc: number = 0,
    [x, y]: [number, number] = [0, 1]
): number {
    if (x > maxValue) { return acc; }

    return isEven(x) ?
        solve(maxValue, acc + x, [y, x + y]) :
        solve(maxValue, acc, [y, x + y]); 
}

console.log(solve(4000000));

  const IPS: SearchField = 'ips';
  const TYPE: SearchField = 'type';

  const substitutions = {
    tag: TAGS,
    group: TAGS,
    name: LABEL,
    title: LABEL,
    ip: IPS,
    is: TYPE
  };

  return substitutions[key] || key;
};

// Returns true if all values in array are true
export const areAllTrue = all(equals(true));

// Returns true if at least ONE value in array is true
export const areAnyTrue = any(equals(true));

// This type is used by 'logic-query-parser
export type ValueType = 'and' | 'or' | 'string';

// This interface is used by 'logic-query-parser
export interface QueryJSON {
  type: ValueType;
  value?: string;
  values?: QueryJSON[];
}

 (acc, key) =>
     R.cond([
         [R.equals('options'), R.always(acc)],
         [R.equals('get'), key => R.concat(acc, [key, 'head'])],
         [R.T, R.concat(acc)]
     ])(key),

 const getChildValidators = (type, values) =>
     R.equals(type, 'array') && Array.isArray(values) && values.length
         ? ['items', values.map(value => buildParameter(joi, value))]
         : null;

export function accessMap(ctx: Koa.Context): Function {
    return getAccessMap([[equals('role:owner'), () => isCurrentUser(ctx)]])(ctx);
}

 uniqWith<ExtendedEvent, ExtendedEvent>((left, right) =>
   equals(left.entity, right.entity)