function* explainInvalid(values, specs, via) { if (values.length !== specs.length) return; // Looks a lot like implementation of Tuple! const pairs = _.zip(specs, values); const isInvalid = ([[, spec], value]) => !isValid(spec, value); const index = _.findIndex(pairs, isInvalid); if (index !== -1) { const [[key, spec], val] = pairs[index]; yield* firstProblem(spec, val, {path: [key], via, _in: [index]}); } }
_ .zip(first, second) .reduce((result, pair) => { return result.concat(pair) })
spendClassic(txouts, solvers) { if (_.some(solvers, solver => solver.solvesSegwit())) return this.spendSegwit(txouts, solvers); if (solvers.length !== this.inputs.length || txouts.length !== solvers.length) throw new Error("The number of solvers must be equal to the number of utxos"); _.forEach(_.zip(_.range(solvers.length), txouts, solvers), list => this.spendSingle(list[0], list[1], list[2]) ); return this.toImmutable(); }
alter(args, function (eachSeries) { var times = _.map(eachSeries.data, 0); //x axis var val = _.map(eachSeries.data, 1); //y axis mathenviroment.setScope(envName,{'source':val}); //add source to the enviroment //evaluate the input equation inside the updated scope var values = evaluate(inputequation,mathenviroment.getScope(envName)); eachSeries.data = _.zip(times, values); //update series with new values //pretty print equation to string (for the axis label) var eq = (isAssign) ? eachSeries.label : inputequation.split(';').slice(-1)[0].split('source').join(eachSeries.label); eachSeries.label = label != null ? label : eq; eachSeries.label = eachSeries.label + unit; return eachSeries; })
function tuple(...predicates) { return { conform: values => (values.length === predicates.length && _.every(_.zip(predicates, values), _.spread(isValid))) ? values : invalidString, unform: _.identity, gen: () => tcg.array(_.map(predicates, gen)), describe: () => [tuple.name, ...describe(predicates)], explain: function*(values, {via}) { yield* explainPredicate(values, predicates, {via}); yield* explainInvalid(values, predicates, via); } }; }
const MockImportBlock = ({ meta, packagedArguments }) => { const mockStatements = meta.mocks .map(importPath => JestMockStatement({ importPath })); const importStatements = _.zip(meta.mocks, meta.originalMocks) .map(([importPath, originalImportPath]) => SpecialImportStatement({ importPath, originalImportPath, packagedArguments, })); const reassignmentStatements = meta.originalMocks .map(originalImportPath => ReassignmentStatement({ originalImportPath, packagedArguments, })); const importStatementStr = importStatements.join('\n'); const reassignmentStatementStr = reassignmentStatements.join('\n'); const mockStatementsStr = mockStatements.join('\n'); return `${importStatementStr}\n\n${reassignmentStatementStr}\n\n${mockStatementsStr}`; }
spendSegwit(txouts, solvers) { if (solvers.length !== this.inputs.length || txouts.length !== solvers.length) throw new Error("The number of solvers must be equal to the number of utxos"); _.forEach(_.zip(_.range(solvers.length), txouts, solvers), list => this.spendSegwitSingle(list[0], list[1], list[2]) ); return this.toImmutable(); }
return _.concat( _.flatten( _.zip( _.reduce(v.boxarts, (prev, curr) => { if (prev.width * prev.height < curr.width * curr.height) {
const uploaded = await uploadFiles(board.uri, attachments, board.keepOriginalFileName); postData.attachments = _.map( _.zip(postData.attachments, uploaded), ([postAttachment, uploadedAttachment]) => { return {
function* explainInvalid(values, predicates, via) { if (values.length !== predicates.length) return; const pairs = _.zip(predicates, values); const isInvalid = _.negate(_.spread(isValid)); const index = _.findIndex(pairs, isInvalid); if (index !== -1) { const [spec, val] = pairs[index]; yield* firstProblem(spec, val, {path: [index], via, _in: [index]}); } }
async (req, res, next) => { try { const assets = _.zip(req.files, req.body.assets);
postData.attachments = _.map( _.zip(req.files || [], postData.attachments || []), ([fileDesc, fileOpts]) => { if (!fileDesc) {
return _.concat( _.flatten( _.zip( _.reduce(v.boxarts, (prev, curr) => { if (prev.width * prev.height < curr.width * curr.height) {