Behaviour #

import { Array as Arr, Order } from "effect"

const scores = [10, 9, 100, 1]

// Plain sort compares as text and changes the input array
const copy = [...scores]
copy.sort()
console.log(copy.join(","))

// Order.Number is a named, reusable comparison. Arr.sort returns a new array.
console.log(Arr.sort(scores, Order.Number).join(","))
console.log(scores.join(","))   // the input did not change

// flip reverses an Order
console.log(Arr.sort(scores, Order.flip(Order.Number)).join(","))
console.log(Arr.sort(["pear", "Apple", "fig"], Order.String).join(","))

// An Order is a function that returns -1, 0 or 1
console.log(Order.Number(1, 2), Order.String("b", "a"), Order.Number(3, 3))

import { Array as Arr, Order } from "effect"

interface Employee {
  readonly name: string
  readonly dept: string
  readonly salary: number
}

const staff: ReadonlyArray<Employee> = [
  { name: "Lin", dept: "eng", salary: 120 },
  { name: "Ada", dept: "eng", salary: 150 },
  { name: "Bob", dept: "ops", salary: 90 },
  { name: "Cy", dept: "ops", salary: 90 }
]

// mapInput: reuse an Order for one field of a larger type
const byDept = Order.mapInput(Order.String, (e: Employee) => e.dept)
const bySalaryDesc = Order.mapInput(Order.flip(Order.Number), (e: Employee) => e.salary)
const byName = Order.mapInput(Order.String, (e: Employee) => e.name)

// combineAll: the first Order decides; ties go to the next one
const ranking = Order.combineAll([byDept, bySalaryDesc, byName])

const show = (es: ReadonlyArray<Employee>) => es.map((e) => e.dept + ":" + e.name + ":" + e.salary).join(" ")

console.log(show(Arr.sort(staff, ranking)))

// sortBy takes the orders directly
console.log(show(Arr.sortBy(byDept, bySalaryDesc, byName)(staff)))

// Order.Struct: one Order per field, applied in field order. Bob and Cy tie, so they keep input order.
const byDeptThenSalary = Order.Struct({ dept: Order.String, salary: Order.Number })
console.log(show(Arr.sort(staff, byDeptThenSalary)))

import { Array as Arr, DateTime, Duration, Order } from "effect"

// clamp: keep a value inside a range
const clampPercent = Order.clamp(Order.Number)({ minimum: 0, maximum: 100 })
console.log(clampPercent(140), clampPercent(-5), clampPercent(42))

// max with the DateTime Order: the later of 2 dates
const later = Order.max(DateTime.Order)
const a = DateTime.makeUnsafe("2024-03-01")
const b = DateTime.makeUnsafe("2024-01-15")
console.log(DateTime.formatIsoDate(later(a, b)))

// isBetween with the DateTime Order: is this date in the first quarter?
const inQ1 = Order.isBetween(DateTime.Order)({
  minimum: DateTime.makeUnsafe("2024-01-01"),
  maximum: DateTime.makeUnsafe("2024-03-31")
})
console.log(inQ1(a), inQ1(DateTime.makeUnsafe("2024-04-02")))

// min with the Duration Order: the shortest of a list
const timeouts = [Duration.seconds(30), Duration.millis(750), Duration.minutes(1)]
const shortest = timeouts.reduce((acc, d) => Order.min(Duration.Order)(acc, d))
console.log(Duration.format(shortest))
console.log(Arr.sort(timeouts, Duration.Order).map(Duration.format).join(" < "))

// The predicates also come from the Order
console.log(Order.isLessThan(Order.String)("apple", "banana"))

import { Array as Arr, Equivalence } from "effect"

interface Contact {
  readonly name: string
  readonly email: string
}

const contacts: ReadonlyArray<Contact> = [
  { name: "Ada", email: "ada@example.com" },
  { name: "Ada L.", email: "ADA@example.com " },
  { name: "Lin", email: "lin@example.com" }
]

// mapInput: compare the normalized email, not the raw string
const normalizedEmail = Equivalence.mapInput(Equivalence.String, (s: string) => s.trim().toLowerCase())
const sameContact = Equivalence.mapInput(normalizedEmail, (c: Contact) => c.email)

console.log(sameContact(contacts[0], contacts[1]), sameContact(contacts[0], contacts[2]))

// The Array module accepts the Equivalence
console.log(Arr.dedupeWith(contacts, sameContact).map((c) => c.name).join(","))

const imported: ReadonlyArray<Contact> = [
  { name: "Ada", email: "ada@example.com" },
  { name: "Zed", email: "zed@example.com" }
]
console.log(Arr.differenceWith(sameContact)(imported, contacts).map((c) => c.name).join(","))
console.log(Arr.containsWith(sameContact)(contacts, { name: "?", email: " LIN@EXAMPLE.COM" }))

// Struct and Tuple: build an Equivalence for a shape from one per field
const samePerson = Equivalence.Struct({ name: Equivalence.String, email: normalizedEmail })
console.log(samePerson(contacts[0], { name: "Ada", email: "ada@example.com" }))

const sameCoord = Equivalence.Tuple([Equivalence.Number, Equivalence.Number])
console.log(sameCoord([1, 2], [1, 2]), sameCoord([1, 2], [2, 1]))

import { Array as Arr, Order } from "effect"

const prices = [250, 25, 1000, 5]

console.log(prices.sort().join(" < "))

import { Array as Arr, Order } from "effect"

interface Book {
  readonly title: string
  readonly pages: number
}

const books: ReadonlyArray<Book> = [
  { title: "Zen", pages: 90 },
  { title: "Ada", pages: 300 },
  { title: "Moby", pages: 600 }
]

const byTitle = Order.mapInput(Order.Number, (b: Book) => b.title)

console.log(Arr.sort(books, byTitle).map((b) => b.title).join(","))

import { Array as Arr, Order } from "effect"

interface Player {
  readonly name: string
  readonly score: number
}

const players: ReadonlyArray<Player> = [
  { name: "Ada", score: 80 },
  { name: "Bob", score: 95 },
  { name: "Cy", score: 80 },
  { name: "Dee", score: 95 }
]

const byName = Order.mapInput(Order.String, (p: Player) => p.name)
const byScoreDesc = Order.mapInput(Order.flip(Order.Number), (p: Player) => p.score)

console.log(Arr.sortBy(byName, byScoreDesc)(players).map((p) => p.name).join(","))

import { Array as Arr, Equivalence } from "effect"

interface Event {
  readonly id: number
  readonly at: string
}

const events: ReadonlyArray<Event> = [
  { id: 1, at: "09:00" },
  { id: 2, at: "09:05" },
  { id: 1, at: "09:07" }   // a retry of event 1
]

console.log(Arr.dedupe(events).length)