TypeScript ramda.without函数代码示例

  protected generateExercises() {
    const numberOfOldWords: number = 6;
    const oldWords = sample(
      without(this.newVocabulary, this.vocabulary),
      numberOfOldWords
    );
    const words = sample(
      [...oldWords, ...this.newVocabulary],
      this.newVocabulary.length + numberOfOldWords
    );

    const version = sample(['a', 'b'], 1);

    return [
      this.createExercise(ExerciseTypes.InfoScreenWithSounds, {
        type: 'ExplanationText',
        text: 'Hören Sie den Laut?',
        sound: `exercises_hoeren_sie_den_laut_${version}`
      }),
      ...map(word => {
        const [phoneme] = sample(this.props.letters, 1);
        return this.createExercise(ExerciseTypes.HasPhoneme, {
          type: 'HasPhoneme',
          word,
          phoneme
        });
      }, words)
    ];
  }

 ...map(word => {
   const otherWords = sample(without([word], this.vocabulary), 3);
   const wordsProp = sample([...otherWords, word], 4);
   return this.createExercise(ExerciseTypes.MatchImage, {
     type: 'MatchImage',
     words: wordsProp,
     correctIndex: indexOf(word, wordsProp)
   });
 }, words)

 const options = map(missingLetterIndex => {
   const opt = sample(
     [
       ...sample(
         without(
           [wordLetters[missingLetterIndex].toLowerCase()],
           this.letters
         ),
         numberOfOptions - 1
       ),
       wordLetters[missingLetterIndex]
     ],
     numberOfOptions
   );
   return wordLetters[missingLetterIndex] ===
     wordLetters[missingLetterIndex].toLowerCase()
     ? map(s => s.toLowerCase(), opt)
     : map(capitalizeFirstLetter, opt);
 }, missing);

  },
  // update :: Number → a → [a] → [a]
  update(index, val, list) {
    return R.update(index, val, list)
  },
  // 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

export const enumDecorator = ({
  modelName,
  fields,
}: {
  modelName: string;
  fields: (Fields & WithHidden) | PositionsField | EnumField;
}): { modelName; fields: (Fields & WithHidden) | PositionsField | EnumField } => {
  const TAG = '[enumDecorator]';
  logger.log(TAG, { fields });

  const enumFilterFields = R.filter(R.propEq('type', DynamicFormTypes.EnumFilter))(fields);
  if (R.not(R.isEmpty(enumFilterFields))) {
    const [, enumFilterField] = R.toPairs(enumFilterFields)[0];
    logger.debug(TAG, { enumFilterField });

    const enums = _.map(
      _.keys(idx(enumFilterField as EnumField, _ => _.options.enumData)),
      castModelName,
    );
    const current = castModelName(R.pathOr('', ['value'])(enumFilterField));
    logger.debug(TAG, { enums, current });

    // check if positions has value already
    // save positions value if no value exists, update models' sequence for else
    const positionsFieldPair = R.compose(
      R.toPairs,
      R.map(field => {
        // raw is the original value, if exists, means it's update request
        if (field.value && !field.raw) {
          const value = R.is(String, field.value) ? JSON.parse(field.value) : field.value;
          return { ...field, value, raw: field.value };
        }
        return { ...field, value: R.path([current, 'value'])(fields), raw: field.value };
      }),
      R.filter(R.pathEq(['options', 'type'], 'SortPosition')),
    )(fields);

    const filteredNames = R.without(current)(enums);
    const filteredFields = R.omit(filteredNames)(fields);
    const wrappedFields = current
      ? R.mergeDeepRight(filteredFields, {
          [current]: {
            isFilterField: true,
            options: { filterType: R.path(['options', 'filterType'])(enumFilterField) },
            value: R.isEmpty(positionsFieldPair)
              ? R.path([current, 'value'])(filteredFields)
              : R.path([0, 1, 'value'])(positionsFieldPair),
          },
          ...R.fromPairs(positionsFieldPair),
        })
      : filteredFields;

    logger.debug(TAG, 'wrappedFields', {
      current,
      filteredNames,
      filteredFields,
      wrappedFields,
      positionsFieldPair,
    });

    return { modelName, fields: wrappedFields };
  }

  return { modelName, fields };
};

  protected generateExercises() {
    const numberOfOldWords: number = 6;
    const oldWords = sample(
      without(this.newVocabulary, this.vocabulary),
      numberOfOldWords
    );
    const words = sample(
      [...oldWords, ...this.newVocabulary],
      this.newVocabulary.length + numberOfOldWords
    );

    const version = sample(['a', 'b'], 1);
    const text: string =
      this.props.difficulty < 0.2
        ? 'Ergänzen Sie den fehlenden Buchstaben.'
        : 'Ergänzen Sie die fehlenden Buchstaben.';

    const sound: string =
      this.props.difficulty < 0.2
        ? `exercises_ergaenzen_sie_den_fehlenden_buchstaben_${version}`
        : `exercises_ergaenzen_sie_die_fehlenden_buchstaben_${version}`;

    {
      /*const wordObj creates String
      const wordLetters array of splitted substrings of the wordObj
      const numberOfOptions
      const numberMissing number of missing letters
      const knownLettersInWord list containing
      const missing
      const options
      */
    }
    return [
      this.createExercise(ExerciseTypes.InfoScreenWithSounds, {
        type: 'ExplanationText',
        text,
        sound
      }),
      this.createExercise(ExerciseTypes.InfoScreen, {
        type: 'TutorialVideo',
        video: 'explanation_missing_letter_esel'
      }),
      ...map(word => {
        const wordObj = this.createWord(word);
        const wordLetters = (wordObj ? wordObj.toString() : word).split('');
        const numberOfOptions: number = 3;
        const numberMissing: number =
          this.props.difficulty < 0.2
            ? 1
            : this.props.difficulty < 0.4
            ? 2
            : this.props.difficulty < 0.6
            ? 3
            : this.props.difficulty < 0.8
            ? 4
            : wordLetters.length;
        const knownLettersInWord = filter(
          i => indexOf(wordLetters[i].toLowerCase(), this.letters) !== -1,
          times(identity, wordLetters.length)
        );
        const missing = sample(knownLettersInWord, numberMissing);
        const options = map(missingLetterIndex => {
          const opt = sample(
            [
              ...sample(
                without(
                  [wordLetters[missingLetterIndex].toLowerCase()],
                  this.letters
                ),
                numberOfOptions - 1
              ),
              wordLetters[missingLetterIndex]
            ],
            numberOfOptions
          );
          return wordLetters[missingLetterIndex] ===
            wordLetters[missingLetterIndex].toLowerCase()
            ? map(s => s.toLowerCase(), opt)
            : map(capitalizeFirstLetter, opt);
        }, missing);
        return this.createExercise(ExerciseTypes.MissingText, {
          type: 'MissingText',
          word,
          text: wordLetters,
          missing,
          options
        });
      }, words)
    ];
  }

  protected generateExercises() {
    const numberOfOldWords: number = 6;
    const oldWords = sample(
      without(this.newVocabulary, this.vocabulary),
      numberOfOldWords
    );
    const words = sample(
      [...oldWords, ...this.newVocabulary],
      this.newVocabulary.length + numberOfOldWords
    );

    const version = sample(['a', 'b'], 1);

    return [
      this.createExercise(ExerciseTypes.InfoScreenWithSounds, {
        type: 'ExplanationText',
        text: 'Verbinden Sie die Silben.',
        sound: `exercises_verbinden_sie_die_silben_${version}`
      }),
      this.createExercise(ExerciseTypes.InfoScreen, {
        type: 'TutorialVideo',
        video: 'explanation_connect_syllables'
      }),
      ...(filter(
        exercise => !!exercise,
        map(word => {
          const wordObj = this.createWord(word);
          if (!wordObj) {
            return undefined;
          }
          const syllablesRawString = wordObj.getRawSingular();
          if (!syllablesRawString || syllablesRawString.indexOf('|') === -1) {
            return undefined;
          }
          const syllables = syllablesRawString.replace(/['-]/g, '').split('|');

          const missingSyllableIndices = sample(
            times(identity, syllables.length),
            1
          );
          try {
            const options = map(missingSyllableIndex => {
              const syllableOptions = this.createOptionsForSyllable(
                syllables[missingSyllableIndex]
              );
              if (!syllableOptions) {
                throw new Error(
                  `ConnectSyllables: Options empty at word ${syllablesRawString}, syllable ${missingSyllableIndex}`
                );
              }
              return syllableOptions;
            }, missingSyllableIndices);

            return this.createExercise(ExerciseTypes.MissingText, {
              type: 'MissingText',
              word,
              text: syllables,
              missing: missingSyllableIndices,
              options
            });
          } catch (err) {
            Sentry.captureException(err);
            return undefined;
          }
        }, words)
        /* tslint:disable-next-line:no-any */
      ) as Array<AbstractExercise<any, any, any>>)
    ];
  }