TypeScript ramda.pluck函数代码示例

 async (data: IOMessage[]) => {
   const to = data[0].to // Should be consistent across batches
   const indexedData = toPairs(data) as Array<[string, IOMessage]>
   const sortedIndexedData = sortByContent(indexedData)
   const originalIndexes = pluck(0, sortedIndexedData) as string[]
   const sortedData = pluck(1, sortedIndexedData) as IOMessage[]
   const strLength = map(obj => JSON.stringify(obj).length, sortedData)
   const batches = batchData(strLength, sortedData)
   const promises = map((batch: IOMessage[]) => !!to ? messagesAPI.translate(to, batch) : Promise.resolve(pluck('content', batch)), batches)
   const translations = await Promise.all(promises).then(res => flatten<string>(res))
   const indexedTranslations = zip(originalIndexes, translations) as Array<[string, string]>
   const translationsInOriginalOrder = sortByOriginalIndex(indexedTranslations)
   return pluck(1, translationsInOriginalOrder)
 }

 R.filter(role => {
   // 判断返回的是否是 ids
   if (user.roles && _.isObjectLike(user.roles[0])) {
     return R.contains(role.id)(R.values(R.pluck('id', user.roles)));
   }
   return R.contains(role.id)(user.roles);
 }),

  /**
   * Return the next running number in an array of records
   * @param {string} prop The property name
   * @param data The array of records containing the property
   */
  static getNextNumber(prop: string, data: Array<any>) {
    if (R.isEmpty(data)) { return 1 }
    const getNextNumber = R.pipe(
      R.sortBy(R.prop(prop)),
      R.pluck(prop),
      R.last()
    );

    return parseInt(getNextNumber(data)) + 1;
  }

function* getUrls(ids: Array<string>): SagaIterator {
  try {
    const bookmarkInfos: Array<BookmarkInfo> = yield all(ids.map((id) => call(getBookmarkInfo, id)))

    const filteredBookmarkInfos = bookmarkInfos.filter(
      R.both(R.propEq('isSimulated', false), R.propEq('type', BOOKMARK_TYPES.BOOKMARK))
    )
    return R.pluck('url', filteredBookmarkInfos)
  } catch (err) {
    console.error(err)

    return []
  }
}

  // adjust :: (a → a) → Number → [a] → [a]
  adjust(index, fn, list) {
    return R.adjust(fn, index, list)
  },
  // remove :: Number → Number → [a] → [a] (drop / dropLast)
  remove(fromIndex, number, list) {
    return R.remove(fromIndex, number, list)
  },
  // without {a∣a∉xs ∩ a∈ys} :: [a] → [a] → [a]
  without(listA, listB) {
    return R.without(listA, listB)
  },

  // sum :: [Number] → Number
  sum(filed, list) {
    return R.compose(R.sum, R.pluck(filed))(list)
  },
  // pluck :: Functor f => k → f {k: v} → f v
  pluck(filed, list) {
    return R.pluck(filed)(list)
  },
  // filter :: Filterable f => (a → Boolean) → f a → f a
  filter(fn, list) {
    return R.filter(fn, list)
  },
  // findIndex :: (a → Boolean) → [a] → Number
  findIndex(field, val, list) {
    return R.findIndex(R.propEq(field, val))(list)
  },
  // concat :: [a] → [a] → [a]
  concat(listA, listB) {

      y
    })
  },
  getPolygonFromPoints (points: TwoDimensionalPoint[]): Line {
    const pointsSorted = R.sortWith([
      R.ascend(R.prop('x')),
      R.ascend(R.prop('y'))
    ])(points) as TwoDimensionalPoint[]

    const minPoint = pointsSorted[0]
    const maxPoint = R.last(pointsSorted)

    const pointsBellow = [minPoint].concat(pointsSorted.filter(point => {
      return isPointBellow(point, minPoint) && isPointBellow(point, maxPoint) && !R.equals(point, maxPoint)
    }))
    const pointsBellowPath = flatten ( zip( R.pluck('x', pointsBellow), R.pluck('y', pointsBellow) ) ) as number[]

    const pointsAbove = R.sortWith([
        R.descend(R.prop('x')),
        R.descend(R.prop('y'))
      ]
    )(R.difference(pointsSorted, pointsBellow))
    const pointsAbovePath = flatten ( zip( R.pluck('x', pointsAbove), R.pluck('y', pointsAbove) ) ) as number[]

    return new Line({
      points: pointsBellowPath.concat(pointsAbovePath),
      closed: true,
      stroke: '#fff',
      strokeWidth: 2,
      tension: 0.2
    })

		.map(res => R.pipe(R.pluck('$user'), R.pluck('email'))(res))

const pluck = <K extends string, T> (p: K) => (list: ReadonlyArray<T>) => rPluck(p, list)

import { LogLevel } from '../../../clients/Logger'
import { GraphQLServiceContext } from '../typings'
import { toArray } from '../utils/array'
import { generatePathName } from '../utils/pathname'

const CACHE_CONTROL_HEADER = 'cache-control'
const META_HEADER = 'x-vtex-meta'
const ETAG_HEADER = 'etag'
const TWO_SECONDS_S = 2
const sender = process.env.VTEX_APP_ID

const getSplunkQuery = (account: string, workspace: string) =>
  `Try this query at Splunk to retrieve error log: 'index=colossus key=log_error sender="${sender}" account=${account} workspace=${workspace}'`

const parseMessage = pluck('message')

const arrayHasError = any(has('errors'))

const filterErrors = filter(has('errors')) as (x: ReadonlyArray<{}>) => ReadonlyArray<{}>

const chainErrors = chain(prop<any, any>('errors'))

const hasError = compose(arrayHasError, toArray)

const parseError = compose(chainErrors, filterErrors, toArray)

const parseErrorResponse = (response: any) => {
  if (hasError(response)) {
    return parseError(response)
  }