const isQueen = R.propEq("rank", "Q"); //←rankがQかどうかを判定する関数
const isSpade = R.propEq("suit", "♠︎"); //スート(マーク)がスペードかどうかを判定する関数
const isQueenOfSpades = R.allPass([isQueen, isSpade]); //オブジェクトを渡して、isQueenかつisSpadeかどうかを判定できる
 
isQueenOfSpades({ rank: "Q", suit: "♣︎" }); //=> false
isQueenOfSpades({ rank: "Q", suit: "♠︎" }); //=> true

const isClub = R.propEq("suit", "♣"); //スートがクローバーかどうかを判定する関数
const isSpade = R.propEq("suit", "♠"); //スートがスペードかどうかを判定する関数
const isBlackCard = R.anyPass([isClub, isSpade]); //カードオブジェクトを渡した際、スートがクローバーあるいはスペードかどうかを判定する関数。
 
isBlackCard({ rank: "10", suit: "♣" }); //=> true クローバーなのでtrue
isBlackCard({ rank: "Q", suit: "♠" }); //=> true スペードなのでtrue
isBlackCard({ rank: "Q", suit: "♦" }); //=> false ダイヤなのでfalse

R.and(true, true); //=> true true && true->true
R.and(true, false); //=> false true && false->false
R.and(false, true); //=> false false && true -> false
R.and(false, false); //=> false false && false -> false

const gt10 = R.gt(R.__, 10); //10以上ならtrue
const lt20 = R.lt(R.__, 20); //20以下ならtrue
const f = R.both(gt10, lt20);
f(15); //=> true
f(30); //=> false

const isNotNil = R.complement(R.isNil); //結果が逆になるisNotNil関数を作成できる
R.isNil(null); //=> true
isNotNil(null); //=> false 逆になっとる
R.isNil(7); //=> false
isNotNil(7); //=> true 逆になっとる

// 数字を受け取って、その数字が偶数か奇数かを判定する関数
const evenOrOdd = (num: number): string => {
  if (num % 2 === 0) {
    return "偶数";
  } else if (num % 2 === 1) {
    return "奇数";
  } else {
    return "数字ではない";
  }
};
 
// evenOrOdd 関数を使って、5 を判定する
const result1 = evenOrOdd(5);
 
// 結果を表示
console.log(result1); // 奇数

// 数字を受け取って、その数字が偶数か奇数かを判定する関数
const evenOrOdd = R.cond([
  [R.equals(0), R.always("偶数")], // 0 のときは偶数と返す
  [R.modulo(R.__, 2), R.always("奇数")], // 2 で割った余りがあるときは奇数と返す
  [R.T, R.always("数字ではない")], // それ以外のときは数字ではないと返す
]);
 
// evenOrOdd 関数を使って、5 を判定する
const result1 = evenOrOdd(5);
 
// 結果を表示
console.log(result1); // 奇数

class Person {
  constructor(name, age) {
    this.name = name;
    this.age = age;
  }
  greet() {
    console.log(`こんにちは、私は${this.name}です。${this.age}歳です。`);
  }
}

// construct 関数をインポートする
const R = require("ramda");
const construct = R.construct;
 
// Person クラスに construct 関数を適用する
const makePerson = construct(Person);
 
// makePerson 関数は、name と age を引数にとり、Person のインスタンスを返す関数になる
const alice = makePerson("Alice", 18); // name: Alice, age: 18
const bob = makePerson("Bob", 20); // name: Bob, age: 20
 
// alice と bob は Person のインスタンスなので、greet メソッドを呼び出せる
alice.greet(); // こんにちは、私は Alice です。18 歳です。
bob.greet(); // こんにちは、私は Bob です。20 歳です。

// construct 関数をインポートする
const R = require("ramda");
const construct = R.construct;
 
// Person クラスは前と同じ
class Person {
  constructor(name, age) {
    this.name = name;
    this.age = age;
  }
  greet() {
    console.log(`こんにちは、私は${this.name}です。${this.age}歳です。`);
  }
}
 
// Person クラスに construct 関数を適用する
const makePerson = construct(Person);
 
// makePerson 関数に name を部分的に適用して、新しい関数を作る
const makeAlice = makePerson("Alice");
 
// makeAlice 関数は、age を引数にとり、name が Alice の Person のインスタンスを返す関数になる
const alice18 = makeAlice(18); // name: Alice, age: 18
const alice20 = makeAlice(20); // name: Alice, age: 20
 
// alice18 と alice20 は Person のインスタンスなので、greet メソッドを呼び出せる
alice18.greet(); // こんにちは、私は Alice です。18 歳です。
alice20.greet(); // こんにちは、私は Alice です。20 歳です。

// constructN関数をインポートする
const R = require("ramda");
const constructN = R.constructN;
 
// Pointクラスは前と同じ
class Point {
  constructor(x, y) {
    this.x = x;
    this.y = y;
  }
  distanceToOrigin() {
    return Math.sqrt(this.x * this.x + this.y * this.y);
  }
}
 
// PointクラスにconstructN関数を適用する
// 引数の数は2つなので、constructN(2, Point)とする
const makePoint = constructN(2, Point);
 
// makePoint関数にxを部分的に適用して、新しい関数を作る
const makePointWithX = makePoint(10);
 
// makePointWithX関数は、yを引数にとり、xが10のPointのインスタンスを返す関数になる
const p3 = makePointWithX(6); // x: 10, y: 6
const p4 = makePointWithX(8); // x: 10, y: 8
 
// p3とp4はPointのインスタンスなので、distanceToOriginメソッドを呼び出せる
console.log(p3.distanceToOrigin()); // 原点からの距離は11.66です
console.log(p4.distanceToOrigin()); // 原点からの距離は12.81です

const defaultTo42 = R.defaultTo(42); //42を返す関数をつくる
 
defaultTo42(null); //=> 42  null, undefined ,Nanのときは42が返る
defaultTo42(undefined); //=> 42
defaultTo42(false); //=> false falseはfalse
defaultTo42("Ramda"); //=> 'Ramda' null, undefined, NaNじゃないのでRamda
// parseInt('string') results in NaN
defaultTo42(parseInt("string")); //=> 42 Nanなので42

const isEven = (num: number): boolean => num % 2 === 0; // 偶数かどうかを判定する関数
const isPositive = (num: number): boolean => num > 0; // 正数かどうかを判定する関数

const isEvenOrPositive = R.either(isEven, isPositive); // 偶数または正数かどうかを判定する関数を返す

const result1 = isEvenOrPositive(2); // 2 は偶数または正数なので、真を返す
const result2 = isEvenOrPositive(-3); // -3 は偶数または正数ではないので、偽を返す
console.log("結果 1 は" + result1 + "ですわ"); // 結果 1 は true ですわ
console.log("結果 2 は" + result2 + "ですわ"); // 結果 2 は false ですわ

// 数値が偶数かどうかを判定する関数
const isEven = (n: number): boolean => n % 2 === 0;
 
// 偶数の場合にメッセージを表示する関数
const sayEven = (n: number): void => console.log("偶数ですわ");
 
// 奇数の場合にメッセージを表示する関数
const sayOdd = (n: number): void => console.log("奇数ですわ");
 
// ifElse 関数に渡して新しい関数を作る
const sayEvenOrOdd = R.ifElse(isEven, sayEven, sayOdd);
 
// 作った関数を試してみる
sayEvenOrOdd(2); // 偶数ですわ
sayEvenOrOdd(3); // 奇数ですわ

// isEmpty 関数をインポートするのですわ
import { isEmpty } from "ramda";
 
// 値が空であるかどうかを判定する関数を使ってみるのですわ
console.log(isEmpty([])); // true と出力されるのですわ
console.log(isEmpty({})); // true と出力されるのですわ
console.log(isEmpty("")); // true と出力されるのですわ
console.log(isEmpty(null)); // true と出力されるのですわ
console.log(isEmpty(undefined)); // true と出力されるのですわ
console.log(isEmpty([1, 2, 3])); // false と出力されるのですわ
console.log(isEmpty({ a: 1, b: 2 })); // false と出力されるのですわ
console.log(isEmpty("hello")); // false と出力されるのですわ

// Person というクラスを定義するのですわ
class Person {
  name: string;
  age: number;
  constructor(name: string, age: number) {
    this.name = name;
    this.age = age;
  }
}
 
// 値が空であるかどうかを判定する関数を使ってみるのですわ
console.log(isEmpty(new Person("Alice", 20))); // false と出力されるのですわ
console.log(isEmpty(new Person("", 0))); // false と出力されるのですわ

// Person というクラスを定義するのですわ
class Person {
  name: string;
  age: number;
  constructor(name: string, age: number) {
    this.name = name;
    this.age = age;
  }
}
 
// 値が Person のインスタンスであり、かつ name と age が空であるかどうかを判定する関数を作るのですわ
const isPersonEmpty = (value: any): boolean => {
  // value が Person のインスタンスであるかどうかを判定するのですわ
  if (value instanceof Person) {
    // value の name と age が空であるかどうかを判定するのですわ
    return isEmpty(value.name) && isEmpty(value.age);
  } else {
    // value が Person のインスタンスでない場合は、false を返すのですわ
    return false;
  }
};
 
// 作った関数を使ってみるのですわ
console.log(isPersonEmpty(new Person("Alice", 20))); // false と出力されるのですわ
console.log(isPersonEmpty(new Person("", 0))); // true と出力されるのですわ

const isEven = (num: number): boolean => num % 2 === 0; // 数字が偶数かどうかを判定する関数

const isOdd = not(isEven); // 数字が奇数かどうかを判定する高階関数
 
console.log(isOdd(1)); // true と表示されますわ
console.log(isOdd(2)); // false と表示されますわ

const isNegative = (num: number): boolean => num < 0; // 数字が負かどうかを判定する関数
 
const isNonNegative = not(isNegative); // 数字が非負（正またはゼロ）かどうかを判定する高階 関 数
 
console.log(isNonNegative(1)); // true と表示されます わ
console.log(isNonNegative(-1)); // false と表示されます わ

const name: string | null = null;
const age: number | undefined = undefined;
console.log(R.or(name, "Anonymous")); // Anonymous
console.log(R.or(age, 25)); // 25

const isAdult = (age: number): boolean => age >= 18;
const canDrink = (age: number): boolean => age >= 20;
const canDrive = (age: number): boolean => R.or(isAdult(age), canDrink(age));
console.log(canDrive(16)); // false
console.log(canDrive(19)); // true
console.log(canDrive(21)); // true

// 人物のオブジェクト
const person = {
  name: "Alice",
  age: 25,
  address: {
    city: "Tokyo",
    country: "Japan",
  },
  hobbies: ["singing", "dancing", "shopping"],
};
 
// pathSatisfies関数をインポート
import { pathSatisfies } from "ramda";
 
// personオブジェクトから名前がAで始まり、年齢が20以上30未満であるかどうかを判定する関数
const isAlice = (obj: object): boolean =>
  pathSatisfies((name: string) => name.startsWith("A"), ["name"], obj) &&
  pathSatisfies((age: number) => age >= 20 && age < 30, ["age"], obj);
 
// 関数を実行して結果を表示
console.log(isAlice(person)); // trueと表示されますわ。

// オブジェクトの配列を作りますわ
const people = [
  { name: "Alice", age: 25, gender: "female" },
  { name: "Bob", age: 30, gender: "male" },
  { name: "Charlie", age: 35, gender: "male" },
];
 
// propSatisfies 関数を使って、年齢が 30 歳以上の人だけをフィルターしますわ
const isOlderThan30 = R.propSatisfies((age: number) => age >= 30, "age");
const olderPeople = R.filter(isOlderThan30, people);
console.log(olderPeople); // [{ name: "Bob", age: 30, gender: "male" }, { name: "Charlie", age: 35, gender: "male" }]
 
// propSatisfies 関数はカリー化されているので、部分適用もできますわ
const isFemale = R.propSatisfies(
  (gender: string) => gender === "female",
  "gender"
);
const femalePeople = R.filter(isFemale, people);
console.log(femalePeople); // [{ name: "Alice", age: 25, gender: "female" }]

const names: string[] = ["Alice", "Bob", "Charlie", "David"];

import R from "ramda";
 
// 名前が"Alice"でない場合にだけ"さん"を付け加える
const addSanUnlessAlice = R.unless(R.equals("Alice"), R.concat(R.__, "さん"));
 
// 配列に適用する
const result = R.map(addSanUnlessAlice, names);
 
// 結果を確認する
console.log(result); // ["Alice", "Bobさん", "Charlieさん", "Davidさん"]

const ages: number[] = [20, 21, 22, 23];

import R from "ramda";
 
// 年齢が20歳未満でない場合にだけ成人という文字列を付け加える
const addAdultUnlessUnder20 = R.unless(
  R.lt(R.__, 20),
  (age) => `${age}歳（成人）`
);
 
// 配列に適用する
const result = R.map(addAdultUnlessUnder20, ages);
 
// 結果を確認する
console.log(result); // ["20歳（成人）", "21歳（成人）", "22歳（成人）", "23歳（成人）"]

import { when } from "ramda";
 
// predicate: 年齢が20歳以上かどうか判定する関数
const isAdult = (age: number): boolean => age >= 20;
 
// transformer: メッセージに「様」を付け加える関数
const addHonorific = (message: string): string => message + "様";
 
// when関数で新しい関数を作る
const greet = when(isAdult, addHonorific);
 
// 新しい関数でメッセージを生成する
console.log(greet("こんにちは")); // こんにちは
console.log(greet("お誕生日おめでとうございます")); // お誕生日おめでとうございます様

import { xor } from "ramda";
 
// list1: あなたが知っている人物の名前
const list1 = ["Alice", "Bob", "Charlie"];
 
// xor 関数で新しい関数を作る
const excludeCommonNames = xor(list1);
 
// 新しい関数で人物の名前が入った配列を処理する
console.log(excludeCommonNames(["Alice", "David", "Eve"])); // ["Bob", "Charlie", "David", "Eve"] (Alice が共通するため除外される)
console.log(excludeCommonNames(["Frank", "Grace"])); // ["Alice", "Bob", "Charlie", "Frank", "Grace"] (何も共通しない)