Top 10 Examples of "ramda in functional component" in JavaScript

// Ramda doesn't strictly break if you pass it an object, but it always
  // returns undefined.
  // $ExpectError
  const findObj = find(o => o == "bar", { foo: "bar" });

  const findxs2: ?{ [k: string]: number | string } = _.findLast(
    _.propEq("a", 2),
    os
  );
  const findxs3: ?{ [k: string]: number | string } = _.findLast(
    _.propEq("a", 4)
  )(os);
  const findxs4: number = _.findIndex(_.propEq("a", 2), os);
  const findxs5: number = _.findIndex(_.propEq("a", 4))(os);
  const findxs6: number = _.findLastIndex(_.propEq("a", 2), os);
  const findxs7: number = _.findLastIndex(_.propEq("a", 4))(os);

  const s: Array = filter(x => x > 1, [1, 2]);
  const s1: Array = _.filter(x => x === "2", ["2", "3"]);
  const s3: { [key: string]: string } = _.filter(x => x === "2", {
    a: "2",
    b: "3"
  });
  const s4 = _.find(x => x === "2", ["1", "2"]);
  //$ExpectError
  const s5: ?{ [key: string]: string } = _.find(x => x === "2", { a: 1, b: 2 });
  const s6: number = _.findIndex(x => x === "2", ["1", "2"]);
  const s7: number = _.findIndex(x => x === "2", { a: "1", b: "2" });
  const forEachxs = _.forEach(x => console.log(x), ns);

  const forEachObj = _.forEachObjIndexed((value, key) => {}, { x: 1, y: 2 });

deleteProperty: function (target, property) {
        expect(R.keys(target).length).toBe(3) // deletion hasn't performed
        // console.log('Deleted %s', property)
        delete target[property]
        return true
      },
      set: function (target, property, value, receiver) {

it('does not allow a mismatched element type to the $ReadOnlyArray', () => {
        const xs: $ReadOnlyArray = ['bar']
        // It is not understood why this fails to be flagged as an error when
        // the 0.26.x libdef passes with the same declaration. The curried form
        // works reliably though.
        //
        // $ShouldExpectErrorButInsteadWorksPleaseFix
        const result: boolean = contains(1, xs)
      })

// Ramda works with $ReadOnlyArray as it is immutable.
  const readOnlyArray: $ReadOnlyArray = [1, 2, 3, 4];
  // $ReadOnlyArray with curried permutations:
  const redxsReadOnly3: number = reduce(subtract, 0, readOnlyArray);
  const redxsReadOnly2_1: number = reduce(subtract, 0)(readOnlyArray);
  const redxsReadOnly1_2: number = reduce(subtract)(0, readOnlyArray);
  const redxsReadOnly1_1_1: number = reduce(subtract)(0)(readOnlyArray);

  // $ExpectError reduce will not work with an object.
  reduce(subtract, 0, { foo: 1, bar: 2 });

  // reduceRight
  const redrxs1: number = _.reduceRight(_.add, 10, ns);
  const redrxs2: string = _.reduceRight(_.concat, "", ss);
  const redrxs3: Array = _.reduceRight(_.concat, [])(
    _.map(x => [x], ss)
  );
  const redrxs3a: string = _.reduceRight(
    //$ExpectError
    (acc: string, value: number): string => acc,
    "",
    ns
  );
  const redrxs3b: string = _.reduceRight(
    (value: number, acc: string): string => acc,
    "",
    ns
  );

  // $ExpectError reduceRight does not support reduced.
  const redrxs4: number = _.reduceRight(
    // $ExpectError reduceRight does not support reduced.

const someObj: { a: string, b: number } = { a: 'a', b: 2 }
  const someMap: { [string]: { a: string, b: number } } = { so: someObj }
  const mapObj: { [string]: string } = _.map((x: { a: string, b: number }): string => x.a)(someMap)

  const functor = {
    x: 1,
    map(f) {
      return f(this.x)
    },
  }

  // Doesn't typecheck (yet) but at least doesn't break
  const mapFxs = _.map(_.toString, functor)

  const double = x => x * 2
  const dxs: Array = _.map(double, [ 1, 2, 3 ])
  const dos: $Shape = _.map(double, obj)

  const appender = (a, b) => [ a + b, a + b ]
  const mapacc:[number, Array] = _.mapAccum(appender, 0, ns)
  const mapacc1:[number, Array] = _.mapAccumRight(appender, 0, ns)

  const nxs: boolean = _.none(x => x > 1, ns)

  const nthxs: ?string = _.nth(2, [ 'curry' ])
  const nthxs1: ?string = _.nth(2)([ 'curry' ])
  //$ExpectError
  const nthxs2: string = _.nth(2, [ 1, 2, 3 ])


  const xxs: Array = _.append(1, [ 1, 2, 3 ])
  const xxxs: Array = _.intersperse(1, [ 1, 2, 3 ])

export default function getLatestVersionNumber(bitIds: BitIds, bitId: BitId): BitId {
  if (!bitId.getVersion().latest) return bitId;

  // If the bitId provided doesn't contain version we want to ignore scope during search always
  // otherwise we will have problems finding the version from the bitmap after we export the component
  // because we tag with a name without scope but the bitmap contain it with the scope name since it was exported
  // without this, we will always just return the first component in the bitmap which is really bad
  const ignoreScope = !bitId.hasScope();

  const similarIds = ignoreScope ? bitIds.filterWithoutScopeAndVersion(bitId) : bitIds.filterWithoutVersion(bitId);
  const allVersionsForId = similarIds.filter(id => id.hasVersion() && !id.isVersionSnap()).map(id => id.version);

  // A case when the provided bitId doesn't exists in the array
  if (R.isEmpty(allVersionsForId)) {
    if (similarIds.length === 1) return similarIds[0];
    if (similarIds.length > 1)
      throw new Error(`found multiple snaps for ${bitId.toString()}, unable to figure which one is the latest`);
    return bitId;
  }

  const maxVersion = semver.maxSatisfying(allVersionsForId, '*');
  if (!maxVersion) {
    throw new Error(
      `semver was not able to find the highest version among the following: ${allVersionsForId.join(', ')}`
    );
  }
  const bitIdWithMaxVersion = bitId.changeVersion(maxVersion);
  const result = ignoreScope ? bitIds.searchWithoutScope(bitIdWithMaxVersion) : bitIds.search(bitIdWithMaxVersion);
  if (!result) {
    throw new Error(`getLatestVersionNumber failed to find the id ${bitIdWithMaxVersion.toString()} within bitIds`);

const pl1: Array = _.pluck(0)([[1, 2], [3, 4]]);

  const rxs: Array = _.range(1, 10);

  const remxs: Array = _.remove(0, 2, ss);
  const remxs1: Array = _.remove(0, 2)(ss);
  const remxs2: Array = _.remove(0)(2)(ss);
  const remxs3: Array = _.remove(0)(2, ss);

  const ys4: Array = _.repeat("1", 10);
  const ys5: Array = _.repeat(1, 10);

  // reduce
  const redxs: number = reduce(_.add, 10, ns);
  const redxs1: string = reduce(_.concat, "", ss);
  const redxs2: Array = reduce(_.concat, [])(_.map(x => [x], ss));
  // Example used in docs: http://ramdajs.com/docs/#reduce
  const redxs4: number = reduce(subtract, 0, [1, 2, 3, 4]);
  // Using accumulator type that differs from the element type (A and B).
  const redxs5: number = reduce((acc, s) => acc + parseInt(s), 0, [
    "1",
    "2",
    "3"
  ]);

  const redux6a: number = reduce((acc, s) => _.reduced(acc), 0, ns)
  const redux6b: number = reduce((acc: number, s: number) => _.reduced(acc), 0, ns)
  const redxs7: number = reduce(
    (acc, s) => acc < 4 ? acc + parseInt(s) : _.reduced(acc),
    0,
    ["1", "2", "3"]
  );

function printTokens(lines) {
  R.map(line => {

    // FIXME: This will break when we move to lazy style parsing
    let lineNo = lines.indexOf(line) + 1

    console.log(" {
      process.stdout.write(`<${token.name}>`)
    }, line)
    console.log("\n/>\n")

  }, lines)
}

fs.readFile(fileName, "utf-8", (err, data) => {
      // die quietly for we have failed
      if (err) {
        return
      }
      if (data && is(String, data)) {
        try {
          let lines
          let lineCounter = 0
          const lineBreak = /\n/g
          const contents = split(lineBreak, data)

          // create a new structure of lines
          const sourceLines = map(line => {
            lineCounter = lineCounter + 1
            // i am sorry my tab-based brethern.
            const source = replace(/\t/, "  ", line)
            return {
              isSelected: lineCounter === lineNumber,
              lineNumber: lineCounter,
              source,
            }
          }, contents)

          // should just load it all?
          const showWholeFile = contents.length < SOURCE_LINES_UP + SOURCE_LINES_DOWN

          if (showWholeFile) {
            lines = sourceLines
          } else {

[either(isNil, isEmpty), always([])],
  [
    T,
    compose(
      // sort by position in tx, then remove it
      map(
        evolve({
          data: compose(
            map(omit(['positionInTx'])),
            sortBy(prop('positionInTx'))
          ),
        })
      ),
      map(reduce(appendRowToTx, { data: [] })),
      values,
      groupBy(prop('id'))
    ),
  ],
]);

module.exports = dataEntriesToTxs;