Examples

Practical examples demonstrating how to use R-Think in real-world engineering scenarios.

Loan Assessment

A sequential protocol that validates loan applications, assesses risk, and makes a decision.

loan-assessment.ts typescript

import { Runtime, Protocol, Rule } from '@r-think/core';

const loanProtocol = Protocol.define({
  id: 'loan-assessment',
  steps: [
    {
      name: 'validate-application',
      action: (ctx) => validateLoanApplication(ctx.input)
    },
    {
      name: 'assess-risk',
      action: (ctx) => assessRiskScore(ctx.input)
    },
    {
      name: 'make-decision',
      action: (ctx) => makeLoanDecision(ctx.assessRisk)
    }
  ]
});

const runtime = Runtime.create({
  id: 'loan-runtime',
  protocol: loanProtocol,
  rules: [
    Rule.required('applicantId'),
    Rule.required('income'),
    Rule.bounded('income', 0, 10000000),
    Rule.bounded('creditScore', 300, 850)
  ]
});

const result = await runtime.execute({
  applicantId: 'APP-001',
  income: 75000,
  creditScore: 720
});

console.log(result.output.decision); // 'approved'
console.log(result.trace.steps[2].output.reason); // 'Credit score above threshold'

Data Pipeline Validation

A parallel protocol that validates data quality across multiple dimensions simultaneously.

data-pipeline.ts typescript

const dataPipeline = Protocol.define({
  id: 'data-validation',
  mode: 'parallel',
  steps: [
    { name: 'schema-check', action: validateSchema },
    { name: 'null-check', action: validateNulls },
    { name: 'range-check', action: validateRanges },
    { name: 'duplicate-check', action: validateDuplicates }
  ],
  aggregate: 'all-passed'
});

const runtime = Runtime.create({
  protocol: dataPipeline,
  artifacts: [Artifact.trace()]
});

const result = await runtime.execute({ dataset });
console.log(result.output.allPassed); // true

Tip

Use parallel mode for independent validation steps. This reduces execution time without sacrificing correctness.

Conditional Routing

Route processing based on runtime conditions using conditional protocols.

conditional.ts typescript

const conditionalProtocol = Protocol.define({
  id: 'conditional-routing',
  steps: [
    {
      name: 'fast-path',
      condition: (ctx) => ctx.priority === 'high',
      action: fastProcessing
    },
    {
      name: 'standard-path',
      condition: (ctx) => ctx.priority === 'normal',
      action: standardProcessing
    },
    {
      name: 'batch-path',
      condition: (ctx) => ctx.priority === 'low',
      action: batchProcessing
    }
  ],
  default: 'standard-path'
});