Ramda。 anyPass with result而不是boolean

Question

我有WordPress休息api的回应。邮政可以有特色图像，它可以是不同的大小。我想拍大片。如果它不存在那么中等然后小。

const data = {
  sizes: {
    small: {
      source: 's.jpg',
    },
    medium: {
      source: 'm.jpg',
    },
  }
};

const prioritizedSizes = ['large', 'medium', 'small'];
const possiblePaths = map((size) => path(['sizes', size, 'source']), sizes)

anyPass是我找到的“最近”函数，但如果其中一个路径有效，则返回true。

我也找到了either功能。同样好，但它只需要2个参数（如果不是第一个，那么第二个）。

任何想法，我怎样才能找到第一个有效路径？

Answer 1

从sizes按顺序提取所有项目，删除缺少的元素（undefined），如果第一个元素不是undefined，请使用source：

const { pipe, propOr, prop, props, head, filter } = R

const getImage = prioritizedSizes => pipe(
  propOr({}, 'sizes'),
  props(prioritizedSizes), // get the ordered sizes
  filter(Boolean), // remove missing sizes (undefined items)
  head, // take the first element
  prop('source') // if found extract source
);

const prioritizedSizes = ['large', 'medium', 'small'];
const getImageBySize = getImage(prioritizedSizes);

const data = {"sizes":{"small":{"source":"s.jpg"},"medium":{"source":"m.jpg"}}};

console.log(getImageBySize(data));
console.log(getImageBySize({}));

<script src="https://cdnjs.cloudflare.com/ajax/libs/ramda/0.26.1/ramda.js"></script>

Answer 2

最后，我改变了一点原创的anyPass，这就是我得到的：

import { curry, curryN, isNil, max, pluck, reduce } from 'ramda';

export const anyPassValue = curry(preds =>
  curryN(reduce(max, 0, pluck('length', preds)), (...args) => {
    let idx = 0;
    const len = preds.length;
    while (idx < len) {
      const callResult = preds[idx].apply(this, args);
      if (!isNil(callResult)) {
        return callResult;
      }
      idx += 1;
    }
    return undefined;
  }),
);

例：

const sizes = ['large', 'medium', 'small'];
const possiblePaths = map(size => path(['media_details', 'sizes', size, 'source_url']), sizes);
anyPassValue(possiblePaths);

Answer 3

我认为首先澄清anyPass的用法很重要。您无法使用它来检查事物的真实性并同时返回有关它的一些信息。

让我们看看这些例子：谓词可以返回一个非布尔值，但它将由anyPass转换为一个：

anyPass([always('foo')])([false]);
//=> true

anyPass([always('')])([true]);
//=> false

因此，您无法检查路径是否存在并使用anyPass同时返回该路径。

这是一个涉及chain的解决方案。 （请注意，我不确定这是否合适。）

const findPath = data => {
  const large = ['sizes', 'large', 'source'];
  const medium = ['sizes', 'medium', 'source'];
  const small = ['sizes', 'small', 'source'];
  return hasPath(large, data) ? large :
    hasPath(medium, data) ? medium : small;
}

const findSize = chain(path, findPath);

findSize({
  sizes: {
    small: {
      source: 's.jpg',
    },
    medium: {
      source: 'm.jpg',
    },
  }
});
// m.jpg

chain(path, findPath)(data)与path(findPath(data), data)相同。

这是使用cond的解决方案：

// sizePath('large') => ["sizes", "large", "source"]
const sizePath = flip(insert(1))(['sizes', 'source']);
const hasSize = compose(hasPath, sizePath)
const getSize = compose(path, sizePath);

const findSize = cond([
  [hasSize('large'), getSize('large')],
  [hasSize('medium'), getSize('medium')],
  [hasSize('small'), getSize('small')],
]);

findSize({
  sizes: {
    small: {
      source: 's.jpg',
    },
    medium: {
      source: 'm.jpg',
    },
  }
});
// m.jpg

这是使用ap的解决方案：

const size = compose(path, flip(insert(1))(['sizes', 'source']));

const findSize = compose(find(complement(isNil)), ap([size('large'), size('medium'), size('small')]), of);

findSize({
  sizes: {
    small: {
      source: 's.jpg',
    },
    medium: {
      source: 'm.jpg',
    },
  }
})

Answer 4

其他人已经解释了为什么anyPass不会在这里为你做。

我认为最简单的版本会使用find，因为你试图找到优先列表中的第一个匹配。这是一个相当简单的解决方案：

const {find, has, __} = R

const firstSize = (priorities) => (data) => 
  data.sizes [find (has (__, data.sizes), priorities) ]

// ----------------------------------------

const data = {"sizes": {"medium": {"source": "m.jpg"}, "small": {"source": "s.jpg"}}}
const prioritizedSizes = ['large', 'medium', 'small'];

console.log(firstSize (prioritizedSizes) (data))

<script src="//cdnjs.cloudflare.com/ajax/libs/ramda/0.26.1/ramda.js"></script>

如果你只想要第一场比赛的名字（例如，'medium'），你可以使用更简单的东西：

(priorities) => (data) => find (has (__, data.sizes), priorities)

Answer 5

你可以递归地写它，像下面的findImage

1. 从左边拿size（高优先级）
2. 横越data直到size或null
3. 如果找到return found
4. elseif length tail findImage(tail)
5. return null

const findImage = ([head, ...sizes]) => R.either(
  R.path(['sizes', head, 'source']),
  R.ifElse(
    R.always(sizes.length), 
    d => findImage(sizes)(d), 
    R.always(null),
  ),
);

const findBestImage = findImage(['large', 'medium', 'small']);

const data = {
  sizes: {
    small: {
      source: 's.jpg',
    },
    medium: {
      source: 'm.jpg',
    },
  }
};

// [Run code snippet]
console.log('best possible image is', findBestImage(data));

<script src="https://cdnjs.cloudflare.com/ajax/libs/ramda/0.26.1/ramda.js"></script>