time-to-botec

Benchmark sampling in different programming languages
Log | Files | Refs | README

_mapping.js (9955B)


      1 /** Used to map aliases to their real names. */
      2 exports.aliasToReal = {
      3 
      4   // Lodash aliases.
      5   'each': 'forEach',
      6   'eachRight': 'forEachRight',
      7   'entries': 'toPairs',
      8   'entriesIn': 'toPairsIn',
      9   'extend': 'assignIn',
     10   'extendAll': 'assignInAll',
     11   'extendAllWith': 'assignInAllWith',
     12   'extendWith': 'assignInWith',
     13   'first': 'head',
     14 
     15   // Methods that are curried variants of others.
     16   'conforms': 'conformsTo',
     17   'matches': 'isMatch',
     18   'property': 'get',
     19 
     20   // Ramda aliases.
     21   '__': 'placeholder',
     22   'F': 'stubFalse',
     23   'T': 'stubTrue',
     24   'all': 'every',
     25   'allPass': 'overEvery',
     26   'always': 'constant',
     27   'any': 'some',
     28   'anyPass': 'overSome',
     29   'apply': 'spread',
     30   'assoc': 'set',
     31   'assocPath': 'set',
     32   'complement': 'negate',
     33   'compose': 'flowRight',
     34   'contains': 'includes',
     35   'dissoc': 'unset',
     36   'dissocPath': 'unset',
     37   'dropLast': 'dropRight',
     38   'dropLastWhile': 'dropRightWhile',
     39   'equals': 'isEqual',
     40   'identical': 'eq',
     41   'indexBy': 'keyBy',
     42   'init': 'initial',
     43   'invertObj': 'invert',
     44   'juxt': 'over',
     45   'omitAll': 'omit',
     46   'nAry': 'ary',
     47   'path': 'get',
     48   'pathEq': 'matchesProperty',
     49   'pathOr': 'getOr',
     50   'paths': 'at',
     51   'pickAll': 'pick',
     52   'pipe': 'flow',
     53   'pluck': 'map',
     54   'prop': 'get',
     55   'propEq': 'matchesProperty',
     56   'propOr': 'getOr',
     57   'props': 'at',
     58   'symmetricDifference': 'xor',
     59   'symmetricDifferenceBy': 'xorBy',
     60   'symmetricDifferenceWith': 'xorWith',
     61   'takeLast': 'takeRight',
     62   'takeLastWhile': 'takeRightWhile',
     63   'unapply': 'rest',
     64   'unnest': 'flatten',
     65   'useWith': 'overArgs',
     66   'where': 'conformsTo',
     67   'whereEq': 'isMatch',
     68   'zipObj': 'zipObject'
     69 };
     70 
     71 /** Used to map ary to method names. */
     72 exports.aryMethod = {
     73   '1': [
     74     'assignAll', 'assignInAll', 'attempt', 'castArray', 'ceil', 'create',
     75     'curry', 'curryRight', 'defaultsAll', 'defaultsDeepAll', 'floor', 'flow',
     76     'flowRight', 'fromPairs', 'invert', 'iteratee', 'memoize', 'method', 'mergeAll',
     77     'methodOf', 'mixin', 'nthArg', 'over', 'overEvery', 'overSome','rest', 'reverse',
     78     'round', 'runInContext', 'spread', 'template', 'trim', 'trimEnd', 'trimStart',
     79     'uniqueId', 'words', 'zipAll'
     80   ],
     81   '2': [
     82     'add', 'after', 'ary', 'assign', 'assignAllWith', 'assignIn', 'assignInAllWith',
     83     'at', 'before', 'bind', 'bindAll', 'bindKey', 'chunk', 'cloneDeepWith',
     84     'cloneWith', 'concat', 'conformsTo', 'countBy', 'curryN', 'curryRightN',
     85     'debounce', 'defaults', 'defaultsDeep', 'defaultTo', 'delay', 'difference',
     86     'divide', 'drop', 'dropRight', 'dropRightWhile', 'dropWhile', 'endsWith', 'eq',
     87     'every', 'filter', 'find', 'findIndex', 'findKey', 'findLast', 'findLastIndex',
     88     'findLastKey', 'flatMap', 'flatMapDeep', 'flattenDepth', 'forEach',
     89     'forEachRight', 'forIn', 'forInRight', 'forOwn', 'forOwnRight', 'get',
     90     'groupBy', 'gt', 'gte', 'has', 'hasIn', 'includes', 'indexOf', 'intersection',
     91     'invertBy', 'invoke', 'invokeMap', 'isEqual', 'isMatch', 'join', 'keyBy',
     92     'lastIndexOf', 'lt', 'lte', 'map', 'mapKeys', 'mapValues', 'matchesProperty',
     93     'maxBy', 'meanBy', 'merge', 'mergeAllWith', 'minBy', 'multiply', 'nth', 'omit',
     94     'omitBy', 'overArgs', 'pad', 'padEnd', 'padStart', 'parseInt', 'partial',
     95     'partialRight', 'partition', 'pick', 'pickBy', 'propertyOf', 'pull', 'pullAll',
     96     'pullAt', 'random', 'range', 'rangeRight', 'rearg', 'reject', 'remove',
     97     'repeat', 'restFrom', 'result', 'sampleSize', 'some', 'sortBy', 'sortedIndex',
     98     'sortedIndexOf', 'sortedLastIndex', 'sortedLastIndexOf', 'sortedUniqBy',
     99     'split', 'spreadFrom', 'startsWith', 'subtract', 'sumBy', 'take', 'takeRight',
    100     'takeRightWhile', 'takeWhile', 'tap', 'throttle', 'thru', 'times', 'trimChars',
    101     'trimCharsEnd', 'trimCharsStart', 'truncate', 'union', 'uniqBy', 'uniqWith',
    102     'unset', 'unzipWith', 'without', 'wrap', 'xor', 'zip', 'zipObject',
    103     'zipObjectDeep'
    104   ],
    105   '3': [
    106     'assignInWith', 'assignWith', 'clamp', 'differenceBy', 'differenceWith',
    107     'findFrom', 'findIndexFrom', 'findLastFrom', 'findLastIndexFrom', 'getOr',
    108     'includesFrom', 'indexOfFrom', 'inRange', 'intersectionBy', 'intersectionWith',
    109     'invokeArgs', 'invokeArgsMap', 'isEqualWith', 'isMatchWith', 'flatMapDepth',
    110     'lastIndexOfFrom', 'mergeWith', 'orderBy', 'padChars', 'padCharsEnd',
    111     'padCharsStart', 'pullAllBy', 'pullAllWith', 'rangeStep', 'rangeStepRight',
    112     'reduce', 'reduceRight', 'replace', 'set', 'slice', 'sortedIndexBy',
    113     'sortedLastIndexBy', 'transform', 'unionBy', 'unionWith', 'update', 'xorBy',
    114     'xorWith', 'zipWith'
    115   ],
    116   '4': [
    117     'fill', 'setWith', 'updateWith'
    118   ]
    119 };
    120 
    121 /** Used to map ary to rearg configs. */
    122 exports.aryRearg = {
    123   '2': [1, 0],
    124   '3': [2, 0, 1],
    125   '4': [3, 2, 0, 1]
    126 };
    127 
    128 /** Used to map method names to their iteratee ary. */
    129 exports.iterateeAry = {
    130   'dropRightWhile': 1,
    131   'dropWhile': 1,
    132   'every': 1,
    133   'filter': 1,
    134   'find': 1,
    135   'findFrom': 1,
    136   'findIndex': 1,
    137   'findIndexFrom': 1,
    138   'findKey': 1,
    139   'findLast': 1,
    140   'findLastFrom': 1,
    141   'findLastIndex': 1,
    142   'findLastIndexFrom': 1,
    143   'findLastKey': 1,
    144   'flatMap': 1,
    145   'flatMapDeep': 1,
    146   'flatMapDepth': 1,
    147   'forEach': 1,
    148   'forEachRight': 1,
    149   'forIn': 1,
    150   'forInRight': 1,
    151   'forOwn': 1,
    152   'forOwnRight': 1,
    153   'map': 1,
    154   'mapKeys': 1,
    155   'mapValues': 1,
    156   'partition': 1,
    157   'reduce': 2,
    158   'reduceRight': 2,
    159   'reject': 1,
    160   'remove': 1,
    161   'some': 1,
    162   'takeRightWhile': 1,
    163   'takeWhile': 1,
    164   'times': 1,
    165   'transform': 2
    166 };
    167 
    168 /** Used to map method names to iteratee rearg configs. */
    169 exports.iterateeRearg = {
    170   'mapKeys': [1],
    171   'reduceRight': [1, 0]
    172 };
    173 
    174 /** Used to map method names to rearg configs. */
    175 exports.methodRearg = {
    176   'assignInAllWith': [1, 0],
    177   'assignInWith': [1, 2, 0],
    178   'assignAllWith': [1, 0],
    179   'assignWith': [1, 2, 0],
    180   'differenceBy': [1, 2, 0],
    181   'differenceWith': [1, 2, 0],
    182   'getOr': [2, 1, 0],
    183   'intersectionBy': [1, 2, 0],
    184   'intersectionWith': [1, 2, 0],
    185   'isEqualWith': [1, 2, 0],
    186   'isMatchWith': [2, 1, 0],
    187   'mergeAllWith': [1, 0],
    188   'mergeWith': [1, 2, 0],
    189   'padChars': [2, 1, 0],
    190   'padCharsEnd': [2, 1, 0],
    191   'padCharsStart': [2, 1, 0],
    192   'pullAllBy': [2, 1, 0],
    193   'pullAllWith': [2, 1, 0],
    194   'rangeStep': [1, 2, 0],
    195   'rangeStepRight': [1, 2, 0],
    196   'setWith': [3, 1, 2, 0],
    197   'sortedIndexBy': [2, 1, 0],
    198   'sortedLastIndexBy': [2, 1, 0],
    199   'unionBy': [1, 2, 0],
    200   'unionWith': [1, 2, 0],
    201   'updateWith': [3, 1, 2, 0],
    202   'xorBy': [1, 2, 0],
    203   'xorWith': [1, 2, 0],
    204   'zipWith': [1, 2, 0]
    205 };
    206 
    207 /** Used to map method names to spread configs. */
    208 exports.methodSpread = {
    209   'assignAll': { 'start': 0 },
    210   'assignAllWith': { 'start': 0 },
    211   'assignInAll': { 'start': 0 },
    212   'assignInAllWith': { 'start': 0 },
    213   'defaultsAll': { 'start': 0 },
    214   'defaultsDeepAll': { 'start': 0 },
    215   'invokeArgs': { 'start': 2 },
    216   'invokeArgsMap': { 'start': 2 },
    217   'mergeAll': { 'start': 0 },
    218   'mergeAllWith': { 'start': 0 },
    219   'partial': { 'start': 1 },
    220   'partialRight': { 'start': 1 },
    221   'without': { 'start': 1 },
    222   'zipAll': { 'start': 0 }
    223 };
    224 
    225 /** Used to identify methods which mutate arrays or objects. */
    226 exports.mutate = {
    227   'array': {
    228     'fill': true,
    229     'pull': true,
    230     'pullAll': true,
    231     'pullAllBy': true,
    232     'pullAllWith': true,
    233     'pullAt': true,
    234     'remove': true,
    235     'reverse': true
    236   },
    237   'object': {
    238     'assign': true,
    239     'assignAll': true,
    240     'assignAllWith': true,
    241     'assignIn': true,
    242     'assignInAll': true,
    243     'assignInAllWith': true,
    244     'assignInWith': true,
    245     'assignWith': true,
    246     'defaults': true,
    247     'defaultsAll': true,
    248     'defaultsDeep': true,
    249     'defaultsDeepAll': true,
    250     'merge': true,
    251     'mergeAll': true,
    252     'mergeAllWith': true,
    253     'mergeWith': true,
    254   },
    255   'set': {
    256     'set': true,
    257     'setWith': true,
    258     'unset': true,
    259     'update': true,
    260     'updateWith': true
    261   }
    262 };
    263 
    264 /** Used to map real names to their aliases. */
    265 exports.realToAlias = (function() {
    266   var hasOwnProperty = Object.prototype.hasOwnProperty,
    267       object = exports.aliasToReal,
    268       result = {};
    269 
    270   for (var key in object) {
    271     var value = object[key];
    272     if (hasOwnProperty.call(result, value)) {
    273       result[value].push(key);
    274     } else {
    275       result[value] = [key];
    276     }
    277   }
    278   return result;
    279 }());
    280 
    281 /** Used to map method names to other names. */
    282 exports.remap = {
    283   'assignAll': 'assign',
    284   'assignAllWith': 'assignWith',
    285   'assignInAll': 'assignIn',
    286   'assignInAllWith': 'assignInWith',
    287   'curryN': 'curry',
    288   'curryRightN': 'curryRight',
    289   'defaultsAll': 'defaults',
    290   'defaultsDeepAll': 'defaultsDeep',
    291   'findFrom': 'find',
    292   'findIndexFrom': 'findIndex',
    293   'findLastFrom': 'findLast',
    294   'findLastIndexFrom': 'findLastIndex',
    295   'getOr': 'get',
    296   'includesFrom': 'includes',
    297   'indexOfFrom': 'indexOf',
    298   'invokeArgs': 'invoke',
    299   'invokeArgsMap': 'invokeMap',
    300   'lastIndexOfFrom': 'lastIndexOf',
    301   'mergeAll': 'merge',
    302   'mergeAllWith': 'mergeWith',
    303   'padChars': 'pad',
    304   'padCharsEnd': 'padEnd',
    305   'padCharsStart': 'padStart',
    306   'propertyOf': 'get',
    307   'rangeStep': 'range',
    308   'rangeStepRight': 'rangeRight',
    309   'restFrom': 'rest',
    310   'spreadFrom': 'spread',
    311   'trimChars': 'trim',
    312   'trimCharsEnd': 'trimEnd',
    313   'trimCharsStart': 'trimStart',
    314   'zipAll': 'zip'
    315 };
    316 
    317 /** Used to track methods that skip fixing their arity. */
    318 exports.skipFixed = {
    319   'castArray': true,
    320   'flow': true,
    321   'flowRight': true,
    322   'iteratee': true,
    323   'mixin': true,
    324   'rearg': true,
    325   'runInContext': true
    326 };
    327 
    328 /** Used to track methods that skip rearranging arguments. */
    329 exports.skipRearg = {
    330   'add': true,
    331   'assign': true,
    332   'assignIn': true,
    333   'bind': true,
    334   'bindKey': true,
    335   'concat': true,
    336   'difference': true,
    337   'divide': true,
    338   'eq': true,
    339   'gt': true,
    340   'gte': true,
    341   'isEqual': true,
    342   'lt': true,
    343   'lte': true,
    344   'matchesProperty': true,
    345   'merge': true,
    346   'multiply': true,
    347   'overArgs': true,
    348   'partial': true,
    349   'partialRight': true,
    350   'propertyOf': true,
    351   'random': true,
    352   'range': true,
    353   'rangeRight': true,
    354   'subtract': true,
    355   'zip': true,
    356   'zipObject': true,
    357   'zipObjectDeep': true
    358 };