Ruby แบบ Functional สำหรับปัญหาข้อมูลในชีวิตประจำวัน

rows = []
names.each_with_index do |name, index|
  score = scores[index]
  next if score < 60

  rows << "#{name}: #{score}"
end

names.zip(scores)
     .select { |_name, score| score >= 60 }
     .map { |name, score| "#{name}: #{score}" }

rows = []
quantities.each_with_index do |qty, index|
  price = prices[index]
  rows << qty * price
end

quantities.zip(prices).map { |qty, price| qty * price }

labels = []
scores.each do |score|
  next if score < 60
  labels << "PASS: #{score}"
end

scores.select { |score| score >= 60 }
      .map { |score| "PASS: #{score}" }

transform = FunctionTools.compose(to_letter, clamp, curve)

scores.map { |score| score + 5 }

scores.select { |score| score >= 60 }

names.zip(scores)

classifier = ->(score) { score >= 60 }

def self.compose(*functions)
  ->(input) { functions.reverse.reduce(input) { |value, fn| fn.call(value) } }
end

# EXAMPLE CODE
# Topic: topic_14_functional_style_lambdas
#
# Purpose:
# - This file demonstrates a small functional-style transform using `zip` and `map`.
# - It should pass tests from the beginning.
# - Read it before solving the reporting and composition exercises.

class VectorMath
  def pairwise_sum(left, right)
    left.zip(right).map { |a, b| a + b }
  end
end

# STUDENT TASK (BASIC)
# Topic: topic_14_functional_style_lambdas
#
# What to do:
# - Pair names and scores with `zip`.
# - Use an injected lambda to decide whether each score passes.
# - Return structured rows instead of printing directly.
#
# Expected outcome:
# - You can solve a small reporting task with `zip`, `map`, and a lambda.

class StudentRoster
  def initialize(classifier:)
    @classifier = classifier
  end

  def rows(names, scores)
    names.zip(scores).map do |name, score|
      {
        name: name,
        score: score,
        passed: @classifier.call(score)
      }
    end
  end
end

# STUDENT TASK (ADVANCED)
# Topic: topic_14_functional_style_lambdas
#
# Academic purpose:
# - Practice function composition as a practical Ruby technique.
# - Show how a sequence of lambdas can model a transformation pipeline.
#
# Real-world use case:
# - Reporting and normalization code often applies several steps in order:
#   curve a score, clamp it, then convert it into a label.
# - Composition lets each step stay small while the pipeline remains reusable.
#
# Why Ruby is beautiful here:
# - Lambdas are lightweight enough to use as ordinary values.
# - Composition keeps each transformation step honest and testable.
# - The final pipeline reads like a sequence of meaning, not a long method body.
#
# What to do:
# - Build one composition helper.
# - Apply the composed transformation to a zipped list of names and scores.
# - Return user-facing labels as strings.
#
# Expected outcome:
# - Advanced tests pass and you can explain how the pipeline is assembled.

module FunctionTools
  def self.compose(*functions)
    ->(input) { functions.reverse.reduce(input) { |value, fn| fn.call(value) } }
  end
end

class GradePipeline
  def initialize(transform:)
    @transform = transform
  end

  def labels(names, scores)
    names.zip(scores).map do |name, score|
      "#{name}: #{@transform.call(score)}"
    end
  end
end

# ANSWER KEY (BASIC)
# Topic: topic_14_functional_style_lambdas
#
# Solution idea:
# - Use `zip` to align names and scores by position.
# - Map over the paired values to build structured rows.
# - Let the lambda decide the pass/fail rule so the object stays generic.

class StudentRoster
  def initialize(classifier:)
    @classifier = classifier
  end

  def rows(names, scores)
    names.zip(scores).map do |name, score|
      {
        name: name,
        score: score,
        passed: @classifier.call(score)
      }
    end
  end
end

# ANSWER KEY (ADVANCED)
# Topic: topic_14_functional_style_lambdas
#
# Solution idea:
# - Composition applies small functions from right to left.
# - The pipeline turns a raw numeric score into a final display label.
# - `GradePipeline` does not know the transformation details; it only applies the function.

module FunctionTools
  def self.compose(*functions)
    ->(input) { functions.reverse.reduce(input) { |value, fn| fn.call(value) } }
  end
end

class GradePipeline
  def initialize(transform:)
    @transform = transform
  end

  def labels(names, scores)
    names.zip(scores).map do |name, score|
      "#{name}: #{@transform.call(score)}"
    end
  end
end

# This spec is your learning companion for topic_14_functional_style_lambdas.
#
# How to use this file:
# 1) Run tests and observe failures or successes.
# 2) Keep the EXAMPLE specs green from the beginning.
# 3) Implement the BASIC exercise as sprint 2 and 3: pairing data and injecting a lambda.
# 4) Implement the ADVANCED exercise as sprint 4: composing functions into a pipeline.
#
# Expected final result:
# - All examples in this file pass.
# - You understand how functional-style Ruby helps solve transformation problems.

require_relative "../example"
require_relative "../basic_exercise"
require_relative "../adv_exercise"

RSpec.describe "topic_14_functional_style_lambdas" do
  describe "EXAMPLE purpose: understand a small data transform with zip and map" do
    it "sums aligned vectors pairwise" do
      math = VectorMath.new

      expect(math.pairwise_sum([1, 2, 3], [10, 20, 30])).to eq([11, 22, 33])
    end
  end

  describe "BASIC EXERCISE purpose: solve a reporting task with zip and a lambda rule" do
    it "builds roster rows with pass/fail status" do
      classifier = ->(score) { score >= 60 }
      roster = StudentRoster.new(classifier: classifier)

      expect(roster.rows(%w[Ana Bob], [88, 52])).to eq(
        [
          { name: "Ana", score: 88, passed: true },
          { name: "Bob", score: 52, passed: false }
        ]
      )
    end
  end

  describe "ADVANCED EXERCISE purpose: compose lambdas into a reusable transformation pipeline" do
    it "curves, clamps, and converts scores into labels" do
      curve = ->(score) { score + 5 }
      clamp = ->(score) { [score, 100].min }
      to_letter = lambda do |score|
        case score
        when 90..100 then "A"
        when 80...90 then "B"
        when 70...80 then "C"
        else "D"
        end
      end

      transform = FunctionTools.compose(to_letter, clamp, curve)
      pipeline = GradePipeline.new(transform: transform)

      expect(pipeline.labels(%w[Ana Bob], [88, 76])).to eq(
        ["Ana: A", "Bob: B"]
      )
    end
  end
end

#!/usr/bin/env bash
set -euo pipefail

SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
ROOT_DIR="$(cd "${SCRIPT_DIR}/.." && pwd)"

exec "${ROOT_DIR}/run_tests.sh" "$(basename "${SCRIPT_DIR}")"