import { all } from "ramda";
 
const arr1 = [3, 3, 3, 3, 3];
const arr2 = [3, 3, 3, 3, 1];
 
const isAll3 = all((x) => x === 3);
 
const arr1Result = isAll3(arr1);
console.log({ arr1Result }); // -> { arr1Result: true }
 
const arr2Result = isAll3(arr2);
console.log({ arr2Result }); // -> { arr2Result: false }
 
/* ライブラリなしで書くなら */
const arr1Result = arr1.every((x) => x === 3);

import { any } from "ramda";
 
const numbers1 = [1, 2, 3, 4, 5];
const isEven = (num: number): boolean => num % 2 === 0;
 
const result1 = any(isEven, numbers1);
console.log({ result1 }); // { result1: true } 偶数条件に合致するものが配列にあるのでtrue
 
const numbers2 = [1, 1, 1, 1, 1];
const result2 = any(isEven, numbers2);
console.log({ result2 }); // { result2: false } 偶数のものが配列に存在しないのでfalse
 
/* 配列のメソッドならこう書けます。 */
const result3 = numbers1.some((x) => isEven(x));
const result4 = numbers2.some((x) => isEven(x));
console.log({ result3, result4 }); // { result3: true, result4: false }

const users = ["TANAKA", "YAMADA"];
const newUser = "NAKAMURA";
const resultUsers = append(newUser, users);
console.log({ resultUsers }); // -> { resultUsers: [ 'TANAKA', 'YAMADA', 'NAKAMURA' ] }
 
/* ライブラリなしで書くなら */
const resultUsers = [...users, newUser];

import { collectBy, prop } from "ramda";
 
type Role = "一般社員" | "バイト" | "社長";
 
type User = {
  id: number;
  name: string;
  role: Role;
};
 
const shatyosan: User = {
  id: 1,
  name: "山田 太郎",
  role: "社長",
};
 
const bite: User = {
  id: 2,
  name: "かむ はなこ",
  role: "バイト",
};
 
const bite2: User = {
  id: 3,
  name: "かむかむ かむこ",
  role: "バイト",
};
 
const user: User = {
  id: 4,
  name: "しゃいん いちろう",
  role: "一般社員",
};
 
/* 上記のようなユーザーが配列に入っていたとする。 */
const users = [shatyosan, bite, bite2, user];
 
/* 社長、バイト、一般社員で配列に分ける関数 */
const collectByRole = (userList: User[]): User[][] =>
  collectBy(prop("role"), userList);
 
const result = collectByRole(users);
console.log(result);
 
/*
[
  [ { id: 1, name: '山田 太郎', role: '社長' } ],
  [
    { id: 2, name: 'かむ はなこ', role: 'バイト' },
    { id: 3, name: 'かむかむ かむこ', role: 'バイト' }
  ],
  [ { id: 4, name: 'しゃいん いちろう', role: '一般社員' } ]
]
このように分類してくれるのだ
*/

import { concat } from "ramda";
 
/* 配列の合体 */
const arr1 = [1, 2, 3];
const arr2 = [4, 5, 6];
 
const result = concat(arr1, arr2);
console.log({ result });
// { result: [ 1, 2, 3, 4, 5, 6 ] }
 
/* ramdaなしでやるならこんな感じ */
const result2 = [...arr1, ...arr2];
console.log({ result2 });
// { result: [ 1, 2, 3, 4, 5, 6 ] }
 
/* そもそも配列のメソッドにもあるよ */
const result3 = arr1.concat(arr2);
console.log({ result3 });
// { result: [ 1, 2, 3, 4, 5, 6 ] }
 
/* 文字も合体できる */
const str1 = "AAAAAA";
const str2 = "BBBBBB";
const result4 = concat(str1, str2);
console.log({ result4 });
// { result5: 'AAAAAABBBBBB' }
 
/* 普通にやるなら */
const result5 = str1 + str2;
console.log({ result5 });
// { result5: 'AAAAAABBBBBB' }

import { count } from "ramda";
 
const countEven = (arr: number[]): number => count((x) => x % 2 === 0, arr);
 
const numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
const result = countEven(numbers);
console.log({ result }); // { result: 5 } (2,4,6,8,10)のカウント
 
type User = {
  id: number;
  name: string;
  age: number;
};
 
const countAge18OverUser = (arr: User[]): number =>
  count((x) => x.age >= 18, arr);
 
const users: User[] = [
  {
    id: 1,
    name: "TANAKA",
    age: 0,
  },
  {
    id: 2,
    name: "YAMADA",
    age: 18,
  },
  {
    id: 3,
    name: "HANAMURA",
    age: 19,
  },
];
 
const result2 = countAge18OverUser(users);
console.log({ result2 }); // { result2: 2 } -> YAMADAとHANAMURAは18歳以上

/*
  例：好きな色の集計を行いたい
*/
 
import { countBy } from "ramda";
 
/* 回答一覧。とりあえずidと名前はなんでもいいのでコピーで使いまわします。好きな色だけ変えてる。 */
const questionnaire1 = {
  id: 1,
  name: "TANAKA",
  favoliteColor: "red",
};
const questionnaire2 = {
  id: 2,
  name: "YAMADA",
  favoliteColor: "blue",
};
const questionnaire3 = {
  id: 2,
  name: "YAMADA",
  favoliteColor: "yellow",
};
const questionnaire4 = {
  id: 2,
  name: "YAMADA",
  favoliteColor: "blue",
};
const questionnaire5 = {
  id: 2,
  name: "YAMADA",
  favoliteColor: "blue",
};
const questionnaire6 = {
  id: 2,
  name: "YAMADA",
  favoliteColor: "yellow",
};
const questionnaire7 = {
  id: 2,
  name: "YAMADA",
  favoliteColor: "blue",
};
const questionnaire8 = {
  id: 2,
  name: "YAMADA",
  favoliteColor: "redi",
};
 
/* もっといろいろ回答があったが、こんな感じでfavoliteColorだけにしたとしよう */
const list = [
  questionnaire1,
  questionnaire2,
  questionnaire3,
  questionnaire4,
  questionnaire5,
  questionnaire6,
  questionnaire7,
  questionnaire8,
];
 
const countFavoliteColors = countBy((x) => x.favoliteColor, list);
console.log({ countFavoliteColors });
// { countFavoliteColors: { red: 1, blue: 4, yellow: 2, redi: 1 } } ←カウントしたことによってtypoしていたことも判明。
 
/*
  countBy の第一引数に関数を渡すことができて、ここでいろいろできます。  
  たとえば下は公式の例ですが、Math.floorで端数を切り捨てて、数字の頻度をカウントしています。 
  const numbers = [1.0, 1.1, 1.2, 2.0, 3.0, 2.2];
  R.countBy(Math.floor)(numbers);    //=> {'1': 3, '2': 2, '3': 1}
*/

R.drop(1, ["foo", "bar", "baz"]); //=> ['bar', 'baz'] 1個目のfooが消えた
R.drop(2, ["foo", "bar", "baz"]); //=> ['baz'] 配列の頭から2個が消えた
R.drop(3, ["foo", "bar", "baz"]); //=> [] 空になった
R.drop(4, ["foo", "bar", "baz"]); //=> [] 超える数のときは空。エラーは返さない
R.drop(3, "ramda"); //=> 'da' 文字の頭3個を消した

R.dropLast(1, ["foo", "bar", "baz"]); //=> ['foo', 'bar']
R.dropLast(2, ["foo", "bar", "baz"]); //=> ['foo']
R.dropLast(3, ["foo", "bar", "baz"]); //=> []
R.dropLast(4, ["foo", "bar", "baz"]); //=> []
R.dropLast(3, "ramda"); //=> 'ra'

R.take(1, ["foo", "bar", "baz"]); //=> ['foo']
R.take(2, ["foo", "bar", "baz"]); //=> ['foo', 'bar']
R.take(3, ["foo", "bar", "baz"]); //=> ['foo', 'bar', 'baz']
R.take(4, ["foo", "bar", "baz"]); //=> ['foo', 'bar', 'baz']
R.take(3, "ramda"); //=> 'ram'

R.takeLast(1, ["foo", "bar", "baz"]); //=> ['baz']
R.takeLast(2, ["foo", "bar", "baz"]); //=> ['bar', 'baz']
R.takeLast(3, ["foo", "bar", "baz"]); //=> ['foo', 'bar', 'baz']
R.takeLast(4, ["foo", "bar", "baz"]); //=> ['foo', 'bar', 'baz']
R.takeLast(3, "ramda"); //=> 'mda'

/* 公式例 */
const isEven = (n) => n % 2 === 0;
R.filter(isEven, [1, 2, 3, 4]); //=> [2, 4]
R.filter(isEven, { a: 1, b: 2, c: 3, d: 4 }); //=> {b: 2, d: 4}
 
/*
  こんな感じでindexを使ったフィルターがjsの配列のmethodではできるが、ramdaだとできない。
  まあ、同じことやりたいならremove関数でよろしいが
  たとえば配列で偶数番目のものだけ抜き出すとかの処理はramdaだとできないかな？
*/
const filterByIndex = (arr: number[], targetIndex: number): number[] =>
  arr.filter((_, i) => i !== targetIndex);
 
/* そういうときはaddIndexを使えばよろしい */
import { addIndex, filter } from "ramda";
 
const numbers = [1, 2, 3, 4, 5, 6];
const filterByEvenIndex = addIndex(filter)((_, i) => i % 2 === 0);
const result = filterByEvenIndex(numbers);
console.log({ result }); // { result: [ 1, 3, 5 ] } 配列の偶数番目だけ
 
const numberObj = [{ a: "a", b: "b", c: "c", d: "d", e: "e" }];
const result2 = filterByEvenIndex(numberObj);
console.log({ result2 }); // { result2: [ { a: 'a', b: 'b', c: 'c', d: 'd', e: 'e' } ] } objectに使ってもindexは足されない

R.uniq([1, 1, 2, 1]); //=> [1, 2]
R.uniq([1, "1"]); //=> [1, '1']
R.uniq([[42], [42]]); //=> [[42]]

R.adjust(1, R.toUpper, ["a", "b", "c", "d"]); //=> ['a', 'B', 'c', 'd']
R.adjust(-1, R.toUpper, ["a", "b", "c", "d"]); //=> ['a', 'b', 'c', 'D']

/* 1と2, 2と3, 3と4, 4と5で同じものが2回使われる配列にしてくれる */
R.aperture(2, [1, 2, 3, 4, 5]); //=> [[1, 2], [2, 3], [3, 4], [4, 5]]
 
/* 123 234 345と1個ずつずれた3個の組 */
R.aperture(3, [1, 2, 3, 4, 5]); //=> [[1, 2, 3], [2, 3, 4], [3, 4, 5]]
 
/* 7つの組をつくれないので空配列が返ってくる */
R.aperture(7, [1, 2, 3, 4, 5]); //=> []

import { chain, isNil } from "ramda";
 
const duplicate = (n: number): number[] => [n, n];
const result = chain(duplicate, [1, 2, 3]);
console.log({ result }); // { result: [ 1, 1, 2, 2, 3, 3 ] }
 
const deleteFalsy = (arr: (number | undefined)[]) =>
  chain((x) => (isNil(x) ? [] : x), arr);
const result2 = deleteFalsy([1, 2, 3, undefined]);
console.log({ result2 }); // { result2: [ 1, 2, 3 ] }

const lteThree = (x: number): boolean => x <= 3; //3以下かどうかをbooleanで判定するpred関数
 
R.dropLastWhile(lteThree, [1, 2, 3, 4, 3, 2, 1]); //=> [1, 2, 3, 4] ←3以下条件に合致しなかった4から後ろを根こそぎ捨てる
 
R.dropLastWhile((x) => x !== "d", "Ramda"); //=> 'Ramd'
/* stringにも使える。xがdかどうかを後ろから判定し、falseになったものから後ろを根こそぎ捨てる */

R.dropRepeats([1, 1, 1, 2, 3, 4, 4, 2, 2]); //=> [1, 2, 3, 4, 2]
/* 1,1,1の部分が連続しているので1になる。2，3はそのまま。4,4と2,2も連続しているので4，2となる */

const l = [1, -1, 1, 3, 4, -4, -4, -5, 5, 3, 3];
R.dropRepeatsWith(R.eqBy(Math.abs), l); //=> [1, 3, 4, -5, 3]
/*
  1, -1, 1はMath.abs(絶対値)で同じものとして判定される -> 1
  3,はそのまま。
  4, -4, -4はMath.abs(絶対値)で同じものとして判定されるので4
  -5, 5も同じものなので-5
  3はそのまま
*/

const lteTwo = (x: number): boolean => x <= 2; //2以下ならばtrue,
 
/* 前から見て1，2はlteTwoなので消す。3はlteTwofalseなのでそれ以降が残る */
R.dropWhile(lteTwo, [1, 2, 3, 4, 3, 2, 1]); //=> [3, 4, 3, 2, 1]
 
R.dropWhile((x) => x !== "d", "Ramda"); //=> 'da'

const keys = ["name", "age", "gender"];
const values = ["Alice", 25, "female"];
const obj = R.zipObj(keys, values); // {name: 'Alice', age: 25, gender: 'female'}

const keys = ["name", "age", "gender"];
const values = ["Bob", 30];
const obj = R.zipObj(keys, values); // {name: 'Bob', age: 30}

const person = ["HCharlie", 35, "male", "engineer"];
const keys = ["name", "age", "gender", "occupation"];
const obj = R.zipObj(keys, person); // {name: 'Charlie', age: 35, gender: 'male', occupation: 'engineer'}

const add = (a, b) => a + b;
const result = R.zipWith(add, [1, 2, 3], [4, 5, 6]); // [5, 7, 9]

const concat = (a, b) => a + b;
const result = R.zipWith(concat, ["a", "b", "c"], ["d", "e", "f"]); // ["ad", "be", "cf"]

const result = R.zipWith(add, [1, 2, 3], [4, 5]); // [5, 7]

// 配列の要素に1を足す関数
const addOne = (x: number): number => x + 1;
 
// 配列の要素に2をかける関数
const multiplyByTwo = (x: number): number => x * 2;
 
// 配列の要素に関数を適用して、結果を配列にまとめる関数
const applyFunctions = (
  fns: Array<(x: number) => number>,
  xs: number[]
): number[][] => {
  return fns.map((fn) => xs.map(fn));
};
 
// 配列の要素に関数を適用して、結果を配列にまとめる関数を実行する
console.log(applyFunctions([addOne, multiplyByTwo], [1, 2, 3]));
// [[2, 3, 4], [2, 4, 6]]

// traverse関数の型
traverse(of: (x: any) => any, fn: (x: any) => any, traversable: any): any;

// 配列の要素に1を足す関数
const addOne = (x: number): number => x + 1;
 
// 配列の要素に2をかける関数
const multiplyByTwo = (x: number): number => x * 2;
 
// 配列の要素に関数を適用して、結果を配列にまとめる関数
const applyFunctions = (
  fns: Array<(x: number) => number>,
  xs: number[]
): number[][] => {
  return R.traverse(R.of, (fn) => R.map(fn, xs), fns);
};
 
// 配列の要素に関数を適用して、結果を配列にまとめる関数を実行する
console.log(applyFunctions([addOne, multiplyByTwo], [1, 2, 3])); // [[2, 3, 4], [2, 4, 6]]

// 2 次元配列
const array: number[][] = [
  [1, 2, 3],
  [4, 5, 6],
  [7, 8, 9],
];

// transpose 関数を実行する
console.log(R.transpose(array));
// [[1, 4, 7], [2, 5, 8], [3, 6, 9]]

// transpose 関数と同じ処理をする関数
const transpose = (array: any[][]): any[][] => {
return array[0].map((\_, colIndex) => array.map(row => row[colIndex]));
};

// トランスデューサーを作る
const transducer = R.compose(
  R.map((num: number): number => num + 1), // 配列の要素に 1 を足す
  R.take(2) // 最初の 2 つの要素だけを取る
);
 
// リダクション関数を定義する
const add = (num1: number, num2: number): number => num1 + num2;
 
// transduce 関数を使って、配列にトランスデューサーとリダクション関数を適用する
const result = R.transduce(
  transducer, // トランスデューサー
  add, // リダクション関数
  0, // 初期値
  [1, 2, 3, 4, 5] // コレクション
);
 
// 結果を表示する
console.log("結果は", result, "です。"); // 結果は 5 です。

// xprod 関数をインポートする
import * as R from "ramda";
 
// xprod 関数を使って、二つの配列の要素の組み合わせを作る
const result = R.xprod(
  [1, 2], // 最初の配列
  ["a", "b", "c"] // 次の配列
);
 
// 結果を表示する
console.log("結果は", result, "です。"); // 結果は [[1, 'a'], [1, 'b'], [1, 'c'], [2, 'a'], [2, 'b'], [2, 'c']] です。

// 配列の要素に1を足す関数
const addOne = (num: number): number => num + 1;
 
// 配列の2番目の要素に1を足す関数
const addOneToSecond = R.adjust(addOne, 1);
 
// 配列を作成
const arr = [1, 2, 3, 4];
 
// 配列の2番目の要素に1を足す
const newArr = addOneToSecond(arr);
 
// 結果を表示
console.log(newArr); // [1, 3, 3, 4]

// 配列の要素を2倍にする関数
const double = (num: number): number => num * 2;
 
// 配列の3番目の要素を2倍にする関数
const doubleThird = R.adjust(2, double);
 
// 配列を作成
const arr = [1, 2, 3, 4];
 
// 配列の3番目の要素を2倍にする
const newArr = doubleThird(arr);
 
// 結果を表示
console.log(newArr); // [1, 2, 6, 4]

const name = "Alice"; // 文字列
const colors = ["red", "green", "blue"]; // 配列

const endsWithE = R.endsWith("e"); // "e"で終わっているかどうかを判定する関数を作る
const endsWithBlue = R.endsWith(["blue"]); // ["blue"]で終わっているかどうかを判定する関数を作る
const nameEndsWithE = endsWithE(name); // name が"e"で終わっているかどうかを判定する
const colorsEndsWithBlue = endsWithBlue(colors); // colors が["blue"]で終わっているかどうかを判定する
console.log("名前は e で終わっていますか？" + nameEndsWithE + "ですわ"); // 名前は e で終わっていますか？true ですわ
console.log("色は blue で終わっていますか？" + colorsEndsWithBlue + "ですわ"); // 色は blue で終わっていますか？true ですわ

// 数字の配列を作りますわ
const numbers: number[] = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
 
// 偶数を見つける関数を作りますわ
const isEven = (n: number): boolean => n % 2 === 0;
 
// find 関数を使って、配列の中から最初の偶数を探しますわ
const firstEven: number | undefined = R.find(isEven, numbers);
 
// 結果を表示しますわ
console.log("配列の中から最初の偶数は" + firstEven + "ですわ");

配列の中から最初の偶数は 2 ですわ

// 文字列の配列を作りますわ
const words: string[] = ["apple", "banana", "cherry", "durian", "elderberry"];
 
// 5文字以上の単語を見つける関数を作りますわ
const isLong = (w: string): boolean => w.length >= 5;
 
// findIndex関数を使って、配列の中から最初の5文字以上の単語のインデックスを探しますわ
const firstLongIndex: number | undefined = R.findIndex(isLong, words);
 
// 結果を表示しますわ
console.log(
  "配列の中から最初の5文字以上の単語のインデックスは" +
    firstLongIndex +
    "ですわ"
);

配列の中から最初の5文字以上の単語のインデックスは1ですわ

// 数字の配列を作りますわ
const numbers: number[] = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
 
// 奇数を見つける関数を作りますわ
const isOdd = (n: number): boolean => n % 2 === 1;
 
// findLast 関数を使って、配列の中から最後の奇数を探しますわ
const lastOdd: number | undefined = R.findLast(isOdd, numbers);
 
// 結果を表示しますわ
console.log("配列の中から最後の奇数は" + lastOdd + "ですわ");

配列の中から最後の奇数は 9 ですわ

// 数字の配列を作りますわ
const numbers: number[] = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
 
// 偶数を見つける関数を作りますわ
const isEven = (n: number): boolean => n % 2 === 0;
 
// findLastIndex 関数を使って、配列の中から最後の偶数のインデックスを探しますわ
const lastEvenIndex: number | undefined = R.findLastIndex(isEven, numbers);
 
// 結果を表示しますわ
console.log(
  "配列の中から最後の偶数のインデックスは" + lastEvenIndex + "ですわ"
);

配列の中から最後の偶数のインデックスは 9 ですわ

// 入れ子になった配列を作りますわ
const nested: any[] = [1, [2, [3, [4, 5]]], 6, [7, 8], 9, 10];
 
// flatten 関数を使って、配列を平坦化しますわ
const flat: any[] = R.flatten(nested);
 
// 結果を表示しますわ
console.log("平坦化された配列は" + flat + "ですわ");

平坦化された配列は 1,2,3,4,5,6,7,8,9,10 ですわ

// 配列を作りますわ
const numbers: number[] = [1, 2, 3, 4, 5];
 
// forEach 関数を使って、配列の各要素に 2 をかけて表示しますわ
const multiplyByTwo = (n: number): void => console.log(n \* 2);
R.forEach(multiplyByTwo, numbers);
 
// オブジェクトを作りますわ
const fruits: { [key: string]: string } = {
apple: "red",
banana: "yellow",
grape: "purple",
};
 
// forEach 関数を使って、オブジェクトの各要素に「色は」をつけて表示しますわ
const addColor = (value: string, key: string): void =>
console.log(key + "の色は" + value + "ですわ");
R.forEachObjIndexed(addColor, fruits);

2
4
6
8
10
apple の色は red ですわ
banana の色は yellow ですわ
grape の色は purple ですわ

// キーと値のペアの配列を作成する
const pairs: [string, number][] = [
  ["a", 1],
  ["b", 2],
  ["c", 3],
];
 
// fromPairs 関数を使ってオブジェクトに変換する
const obj: { [key: string]: number } = R.fromPairs(pairs);
 
// 結果を確認する
console.log(obj); // {a: 1, b: 2, c: 3}

// オブジェクトを作成する
const obj: { [key: string]: number } = { a: 1, b: 2, c: 3 };
 
// toPairs 関数と fromPairs 関数を使ってキーと値を入れ替える
const inverted: { [key: number]: string } = R.pipe(
  R.toPairs, // オブジェクトをキーと値のペアの配列に変換する
  R.map(R.reverse), // 配列の各要素を反転する
  R.fromPairs // 配列をオブジェクトに変換する
)(obj);
 
// 結果を確認する
console.log(inverted); // {1: "a", 2: "b", 3: "c"}

// 配列を作成する
const animals: { name: string; type: string }[] = [
  { name: "Fluffy", type: "cat" },
  { name: "Fido", type: "dog" },
  { name: "Nemo", type: "fish" },
  { name: "Garfield", type: "cat" },
  { name: "Lassie", type: "dog" },
  { name: "Dory", type: "fish" },
];
 
// groupBy 関数を使って動物の種類ごとにグループ化する
const groups: { [key: string]: { name: string; type: string }[] } = R.groupBy(
  R.prop("type"),
  animals
);
 
// 結果を確認する
console.log(groups); // {cat: [{name: "Fluffy", type: "cat"}, {name: "Garfield", type: "cat"}], dog: [{name: "Fido", type: "dog"}, {name: "Lassie", type: "dog"}], fish: [{name: "Nemo", type: "fish"}, {name: "Dory", type: "fish"}]}

// 配列を作成する
const numbers: number[] = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
 
// groupBy 関数を使って偶数と奇数にグループ化する
const groups: { [key: string]: number[] } = R.groupBy(
  (n: number): string => (n % 2 === 0 ? "even" : "odd"),
  numbers
);
 
// 結果を確認する
console.log(groups); // {even: [2, 4, 6, 8, 10], odd: [1, 3, 5, 7, 9]}

// 配列を作成する
const numbers: number[] = [0, 1, 1, 2, 3, 5, 8, 13, 21];
 
// groupWith 関数を使って隣接する偶数と奇数にグループ化する
const groups: number[][] = R.groupWith(
  (a: number, b: number): boolean => a % 2 === b % 2,
  numbers
);
 
// 結果を確認する
console.log(groups); // [[0], [1, 1], [2], [3, 5], [8], [13, 21]]

// 配列を作成する
const words: string[] = [
  "apple",
  "banana",
  "cherry",
  "date",
  "elderberry",
  "fig",
  "grape",
];
 
// groupWith 関数を使って隣接する単語の長さが同じかどうかでグループ化する
const groups: string[][] = R.groupWith(
  (a: string, b: string): boolean => a.length === b.length,
  words
);
 
// 結果を確認する
console.log(groups); // [["apple"], ["banana", "cherry"], ["date"], ["elderberry"], ["fig"], ["grape"]]

// 配列の要素をすべて足し合わせる関数
const sum = (arr: number[]): number => {
  // 配列が空なら 0 を返す
  if (arr.length === 0) {
    return 0;
  }
  // 配列の最初の要素と残りの要素の合計を足す
  return head(arr) + sum(tail(arr));
};
 
// テスト
console.log("配列[1, 2, 3, 4, 5]の合計は" + sum([1, 2, 3, 4, 5]) + "ですわ"); // 15

const isEven = (n: number): boolean => n % 2 === 0;
const list = [1, 2, 3, 4, 5];
const str = "Hello, world!";
 
console.log(R.includes(2, list)); // true
console.log(R.includes(6, list)); // false
console.log(R.includes("o", str)); // true
console.log(R.includes("z", str)); // false
 
console.log(R.includes(isEven, list)); // false
console.log(R.includes(isEven, [isEven, isOdd])); // true

const hasTwo = R.includes(2); // 部分適用された関数
const hasO = R.includes("o"); // 部分適用された関数
 
console.log(hasTwo(list)); // true
console.log(hasTwo([6, 7, 8])); // false
console.log(hasO(str)); // true
console.log(hasO("Goodbye")); // true

const list2 = [
  [1, 2],
  [3, 4],
  [5, 6],
];
const str2 = "Hello, Ramda!";
 
console.log(R.filter(hasTwo, list2)); // [[1, 2]]
console.log(R.find(hasO, str2)); // "o"

const person = (name: string, age: number): { name: string; age: number } => ({
  name,
  age,
});
const list = [person("Alice", 20), person("Bob", 25), person("Charlie", 30)];
const byName = R.indexBy(R.prop("name")); // 部分適用された関数
const byAge = R.indexBy(R.prop("age")); // 部分適用された関数
 
console.log(byName(list)); // {Alice: {name: "Alice", age: 20}, Bob: {name: "Bob", age: 25}, Charlie: {name: "Charlie", age: 30}}
console.log(byAge(list)); // {20: {name: "Alice", age: 20}, 25: {name: "Bob", age: 25}, 30: {name: "Charlie", age: 30}}

const animal = (
  name: string,
  type: string
): { name: string; type: string } => ({ name, type });
const list2 = [
  animal("Leo", "lion"),
  animal("Mimi", "cat"),
  animal("Rex", "dog"),
  animal("Nana", "cat"),
  animal("Spot", "dog"),
];
const byType = R.indexBy(R.prop("type")); // 部分適用された関数
 
console.log(byType(list2)); // {lion: {name: "Leo", type: "lion"}, cat: {name: "Nana", type: "cat"}, dog: {name: "Spot", type: "dog"}}

const list3 = ["apple", "banana", "cherry", "date", "elderberry"];
const byFirstLetter = R.indexBy(R.head); // 部分適用された関数
 
console.log(byFirstLetter(list3)); // {a: "apple", b: "banana", c: "cherry", d: "date", e: "elderberry"}

const list4 = [1, 2, 3, 4, 5];
const byEvenOdd = R.indexBy((x: number): string =>
  x % 2 === 0 ? "even" : "odd"
); // 部分適用された関数
 
console.log(byEvenOdd(list4)); // {even: 4, odd: 5}

// 配列を作りますわ
const fruits = ["apple", "banana", "cherry", "durian", "elderberry"];
 
// ramda.jsのindexOf関数をインポートしますわ
const R = require("ramda");
 
// indexOf関数の型は、(a, [a]) -> Numberですわ
// aは任意の型、[a]はaの配列、Numberは数値型を表しますわ
 
// 配列の中から"cherry"という要素を探して、そのインデックスを返しますわ
const index1 = R.indexOf("cherry", fruits); // 2
 
// indexOf関数に配列だけを与えて、新しい関数を作りますわ
const findIndex = R.indexOf(fruits);
 
// 新しい関数に値を与えて、そのインデックスを返しますわ
const index2 = findIndex("durian"); // 3
 
// コンソールに結果を表示しますわ
console.log("cherryのインデックスは" + index1 + "ですわ"); // cherryのインデックスは2ですわ
console.log("durianのインデックスは" + index2 + "ですわ"); // durianのインデックスは3ですわ

const R = require("ramda"); // ramda.js を読み込むのですわ
const init = (arr: any[] | string): any[] | string => R.init(arr); // init 関数を定義するのですわ
console.log(init([1, 2, 3, 4])); // [1, 2, 3]と表示されるのですわ
console.log(init("hello")); // "hell"と表示されるのですわ

// 配列の2番目の位置に"hello"を挿入する関数を作る
const insertHello = R.insert(2, "hello");
 
// 配列に適用する
const arr = ["a", "b", "c", "d"];
const newArr = insertHello(arr); // ["a", "b", "hello", "c", "d"]
 
// 配列の内容を確認する
console.log("元の配列はこうですわ: " + arr); // 元の配列はこうですわ: a,b,c,d
console.log("新しい配列はこうですわ: " + newArr); // 新しい配列はこうですわ: a,b,hello,c,d

// 配列の2番目の位置に要素を挿入する関数を作る
const insertAt2 = R.insert(2);
 
// 文字列を挿入する関数を作る
const insertHelloAt2 = insertAt2("hello");
 
// 配列に適用する
const arr = ["a", "b", "c", "d"];
const newArr = insertHelloAt2(arr); // ["a", "b", "hello", "c", "d"]
 
// 配列の内容を確認する
console.log("元の配列はこうですわ: " + arr); // 元の配列はこうですわ: a,b,c,d
console.log("新しい配列はこうですわ: " + newArr); // 新しい配列はこうですわ: a,b,hello,c,d

// 配列の 2 番目の位置に["hello", "world"]を挿入する関数を作る
const insertHelloWorld = R.insertAll(2, ["hello", "world"]);
 
// 配列に適用する
const arr = ["a", "b", "c", "d"];
const newArr = insertHelloWorld(arr); // ["a", "b", "hello", "world", "c", "d"]
 
// 配列の内容を確認する
console.log("元の配列はこうですわ: " + arr); // 元の配列はこうですわ: a,b,c,d
console.log("新しい配列はこうですわ: " + newArr); // 新しい配列はこうですわ: a,b,hello,world,c,d

// 配列の 2 番目の位置に要素を挿入する関数を作る
const insertAt2 = R.insertAll(2);
 
// 配列を挿入する関数を作る
const insertHelloWorldAt2 = insertAt2(["hello", "world"]);
 
// 配列に適用する
const arr = ["a", "b", "c", "d"];
const newArr = insertHelloWorldAt2(arr); // ["a", "b", "hello", "world", "c", "d"]
 
// 配列の内容を確認する
console.log("元の配列はこうですわ: " + arr); // 元の配列はこうですわ: a,b,c,d
console.log("新しい配列はこうですわ: " + newArr); // 新しい配列はこうですわ: a,b,hello,world,c,d

// intersperse関数をインポートする
import { intersperse } from "ramda";
 
// 配列を用意する
const arr = ["a", "b", "c", "d"];
 
// intersperse関数にセパレーターと配列を渡す
const newArr = intersperse<string>("x", arr); // ["a", "x", "b", "x", "c", "x", "d"]
 
// 配列の内容を確認する
console.log("元の配列はこうですわ: " + arr); // 元の配列はこうですわ: a,b,c,d
console.log("セパレーターを挿入した配列はこうですわ: " + newArr); // セパレーターを挿入した配列はこうですわ: a,x,b,x,c,x,d

// intersperse関数とjoin関数をインポートする
import { intersperse, join } from "ramda";
 
// 文字列の配列を用意する
const arr = ["apple", "banana", "cherry"];
 
// intersperse関数にカンマと配列を渡して、join関数に空文字と渡す
const str = join("", intersperse<string>(",", arr)); // "apple,banana,cherry"
 
// 文字列の内容を確認する
console.log("元の配列はこうですわ: " + arr); // 元の配列はこうですわ: apple,banana,cherry
console.log("カンマ区切りの文字列はこうですわ: " + str); // カンマ区切りの文字列はこうですわ: apple,banana,cherry

// into 関数と map 関数をインポートする
import { into, map } from "ramda";
 
// 配列を用意する
const arr = [1, 2, 3, 4];
 
// into 関数に空の配列と map 関数と配列を渡す
const newArr = into<number[], number[], number[]>([], map(x => x \* 2), arr); // [2, 4, 6, 8]
 
// 配列の内容を確認する
console.log("元の配列はこうですわ: " + arr); // 元の配列はこうですわ: 1,2,3,4
console.log("変換関数を適用した配列はこうですわ: " + newArr); // 変換関数を適用した配列はこうですわ: 2,4,6,8

// into 関数と filter 関数と sort 関数をインポートする
import { into, filter, sort } from "ramda";
 
// オブジェクトの配列を用意する
const arr = [
  { name: "Alice", age: 20 },
  { name: "Bob", age: 25 },
  { name: "Charlie", age: 22 },
  { name: "David", age: 23 },
];
 
// into 関数に空の配列と filter 関数と sort 関数と配列を渡す
const newArr = into<object[], object[], object[]>(
  [],
  filter((x) => x.age > 21), // 21 歳以上の要素を抽出する
  sort((a, b) => a.name.localeCompare(b.name)), // 名前で昇順にソートする
  arr
); // [{ name: "Bob", age: 25 }, { name: "Charlie", age: 22 }, { name: "David", age: 23 }]
 
// 配列の内容を確認する
console.log("元の配列はこうですわ: " + JSON.stringify(arr)); // 元の配列はこうですわ: [{"name":"Alice","age":20},{"name":"Bob","age":25},{"name":"Charlie","age":22},{"name":"David","age":23}]
console.log("変換関数を適用した配列はこうですわ: " + JSON.stringify(newArr)); // 変換関数を適用した配列はこうですわ: [{"name":"Bob","age":25},{"name":"Charlie","age":22},{"name":"David","age":23}]

// invert 関数をインポートする
import { invert } from "ramda";
 
// オブジェクトを用意する
const obj = { a: "1", b: "2", c: "3" };
 
// invert 関数にオブジェクトを渡す
const newObj = invert<string, string>(obj); // { "1": "a", "2": "b", "3": "c" }
 
// オブジェクトの内容を確認する
console.log("元のオブジェクトはこうですわ: " + JSON.stringify(obj)); // 元のオブジェクトはこうですわ: {"a":"1","b":"2","c":"3"}
console.log(
  "キーと値を入れ替えたオブジェクトはこうですわ: " + JSON.stringify(newObj)
); // キーと値を入れ替えたオブジェクトはこうですわ: {"1":"a","2":"b","3":"c"}

// invert 関数をインポートする
import { invert } from "ramda";
 
// オブジェクトを用意する
const obj = { red: "#FF0000", green: "#00FF00", blue: "#0000FF" };
 
// invert 関数にオブジェクトを渡す
const newObj = invert<string, string>(obj); // { "#FF0000": "red", "#00FF00": "green", "#0000FF": "blue" }
 
// オブジェクトの内容を確認する
console.log("元のオブジェクトはこうですわ: " + JSON.stringify(obj)); // 元のオブジェクトはこうですわ: {"red":"#FF0000","green":"#00FF00","blue":"#0000FF"}
console.log(
  "キーと値を入れ替えたオブジェクトはこうですわ: " + JSON.stringify(newObj)
); // キーと値を入れ替えたオブジェクトはこうですわ: {"#FF0000":"red","#00FF00":"green","#0000FF":"blue"}

// invert 関数をインポートする
import { invert } from "ramda";
 
// オブジェクトを用意する
const obj = { a: [1, 2, 3], b: [4, 5], c: [6] };
 
// invert 関数にオブジェクトを渡す
const newObj = invert<number[], string>(obj); // { "1": ["a"], "2": ["a"], "3": ["a"], "4": ["b"], "5": ["b"], "6":
// オブジェクトの内容を確認する
console.log("元のオブジェクトはこうですわ: " + JSON.stringify(obj)); // 元のオブジェクトはこうですわ: {"a":[1,2,3],"b":[4,5],"c":[6]}
console.log(
  "キーと値を入れ替えたオブジェクトはこうですわ: " + JSON.stringify(newObj)
); // キーと値を入れ替えたオブジェクトはこうですわ: {"1":["a"],"2":["a"],"3":["a"],"4":["b"],"5":["b"],"6":["c"]}

// invert 関数をインポートする
import { invert } from "ramda";
 
// オブジェクトを用意する
const obj = { a: { x: 1, y: 2 }, b: { z: 3 } };
 
// invert 関数にオブジェクトを渡す
const newObj = invert<any, string>(obj); // Error: Cannot convert object to primitive value
 
// オブジェクトの内容を確認する
console.log("元のオブジェクトはこうですわ: " + JSON.stringify(obj)); // 元のオブジェクトはこうですわ: {"a":{"x":1,"y":2},"b":{"z":3}}
console.log(
  "キーと値を入れ替えたオブジェクトはこうですわ: " + JSON.stringify(newObj)
); // キーと値を入れ替えたオブジェクトはこうですわ: Error: Cannot convert object to primitive value

// join 関数をインポートするのですわ
import { join } from "ramda";
 
// 配列を受け取って、その要素を指定した区切り文字で連結した文字列を返す関数を使ってみるのですわ
console.log(join("-", ["a", "b", "c"])); // 'a-b-c'と出力されるのですわ
console.log(join(" ", ["Hello", "world"])); // 'Hello world'と出力されるのですわ
console.log(join("", [1, 2, 3])); // '123'と出力されるのですわ

// join 関数をインポートするのですわ
import { join } from "ramda";
 
// 配列を受け取って、その要素を指定した区切り文字で連結した文字列を返す関数を使ってみるのですわ
// 配列の要素の型を string に限定するのですわ
const joinStringArray = (separator: string, array: string[]): string =>
  join(separator, array);
 
console.log(joinStringArray("-", ["a", "b", "c"])); // 'a-b-c'と出力されるのですわ
console.log(joinStringArray(" ", ["Hello", "world"])); // 'Hello world'と出力されるのですわ
console.log(joinStringArray("", [1, 2, 3])); // エラーが発生するのですわ。配列の要素が string ではないからですわ

const numbers: number[] = [1, 2, 3, 4, 5];
const word: string = "hello";

const lastNumber = last(numbers);
console.log(lastNumber); // 5と表示されますわ
 
const lastChar = last(word);
console.log(lastChar); // "o"と表示されますわ

const isNotEmpty = (arrOrStr: any[] | string): boolean => {
  return last(arrOrStr) != null;
};
 
console.log(isNotEmpty(numbers)); // trueと表示されますわ
console.log(isNotEmpty(word)); // trueと表示されますわ
console.log(isNotEmpty([])); // falseと表示されますわ
console.log(isNotEmpty("")); // falseと表示されますわ

const numbers: number[] = [1, 2, 3, 4, 5, 3, 2, 1];
const word: string = "hello";

const lastIndexOfThree = lastIndexOf(3, numbers);
console.log(lastIndexOfThree); // 5と表示されますわ
 
const lastIndexOfL = lastIndexOf("l", word);
console.log(lastIndexOfL); // 3と表示されますわ