import { assoc } from "ramda";
 
const user = { id: 1 };
const user2 = { id: 2 };
const user3 = { id: 3 };
 
/* カリー化した場合 */
const addNameUser = assoc("name", "TANAKA")(user);
console.log(addNameUser); // { id: 1, name: 'TANAKA' }
 
/* 3つ引数を渡す場合 */
const addNameUser2 = assoc("name", "YAMADA", user2);
console.log(addNameUser2); // { id: 2, name: 'YAMADA' }
 
/* ramdaを使わないならこんな感じ */
const addNameuser3 = { ...user3, name: "HIRAYAMA" };
console.log(addNameuser3); // { id: 3, name: 'HIRAYAMA' }

type User = {
  id: number;
  name: string;
};
const user4 = { id: 4, name: "ISHIDA" };
const newUser: User = assoc("address", "京都府京都市駅前1丁目1-1-1", user4);
console.log({ newUser }); // { newUser: { id: 4, name: 'ISHIDA', address: '京都府京都市駅前1丁目1-1-1' } }

R.prop("x", { x: 100 }); //=> 100
R.prop("x", {}); //=> undefined
R.prop(0, [100]); //=> 100
R.compose(R.inc, R.prop("x"))({ x: 3 }); //=> 4

import { clone } from "ramda";
 
const shallowCopy = () => {
  const post = { id: 1, title: "ご挨拶" };
  const obj = { id: 1, name: "TANAKA", posts: [post] };
  const obj2 = { ...obj };
  if (obj2.posts[0] === undefined) return;
  obj2.posts[0].title = "ご挨拶(修正版)";
  console.log(obj2); // { id: 1, name: 'TANAKA', posts: [ { id: 1, title: 'ご挨拶(修正版)' } ] }
  console.log(obj); // { id: 1, name: 'TANAKA', posts: [ { id: 1, title: 'ご挨拶(修正版)' } ] } ←変わってしまった！
};
shallowCopy();
 
const deepCopy = () => {
  const post = { id: 1, title: "ご挨拶" };
  const obj = { id: 1, name: "TANAKA", posts: [post] };
  const obj2 = clone(obj);
  if (obj2.posts[0] === undefined) return;
  obj2.posts[0].title = "ご挨拶(修正版)";
  console.log(obj2); // { id: 1, name: 'TANAKA', posts: [ { id: 1, title: 'ご挨拶(修正版)' } ] }
  console.log(obj); // { id: 1, name: 'TANAKA', posts: [ { id: 1, title: 'ご挨拶' } ] } ←変わってない！
};
deepCopy();

dissoc("b", { a: 1, b: 2, c: 3 }); //=> {a: 1, c: 3}

/* aのなかのbのなかのcを消す */
R.dissocPath(["a", "b", "c"], { a: { b: { c: 42 } } }); //=> {a: {b: {}}}

values({ a: 1, b: 2, c: 3 }); //=> [1, 2, 3]

keys({ a: 1, b: 2, c: 3 }); //=> ['a', 'b', 'c']

toPairs({ a: 1, b: 2, c: 3 }); //=> [['a', 1], ['b', 2], ['c', 3]]

/* aのなかのbのなかのcに42という値を与えたい */
R.assocPath(["a", "b", "c"], 42, { a: { b: { c: 0 } } }); //=> {a: {b: {c: 42}}}
 
// Any missing or non-object keys in path will be overridden
/* bとかcがないときは追加される */
R.assocPath(["a", "b", "c"], 42, { a: 5 }); //=> {a: {b: {c: 42}}}

typescript
const obj = {
a: 1,
b: 2,
c: 3
};

// obj のプロトタイプに d というプロパティを追加する
Object.prototype.d = 4;

// toPairsIn 関数の型は、
// (obj: object) => [string, any][]
// となります。
// obj はオブジェクト型、返り値は文字列と任意の型のペアの配列型です。

// toPairsIn 関数を obj に適用すると、
// [[a, 1], [b, 2], [c, 3], [d, 4]]
// という配列が返ります。
// 継承された d プロパティも含まれています。
const result = R.toPairsIn(obj);

// 結果をコンソールに出力する
console.log("obj のすべてのプロパティを[key, value]のペアに変換した結果は、");
console.log(result);

const alice = { name: "Alice", age: 20, hair: "blonde" }; // Alice という名前で 20 歳でブロンドの髪のオブジェクト
const bob = { name: "Bob", age: 20, hair: "brown" }; // Bob という名前で 20 歳でブラウンの髪のオブジェクト
const charlie = { name: "Charlie", age: 25, hair: "blonde" }; // Charlie という名前で 25 歳でブロンドの髪のオブジェクト

const eqByAge = R.eqProps("age"); // age プロパティの値が等しいかどうかを判定する関数を作る
const aliceAndBob = eqByAge(alice, bob); // alice と bob の age プロパティの値が等しいかどうかを判定する
const aliceAndCharlie = eqByAge(alice, charlie); // alice と charlie の age プロパティの値が等しいかどうかを判定する
console.log("Alice と Bob は同じ年齢ですか？" + aliceAndBob + "ですわ"); // Alice と Bob は同じ年齢ですか？true ですわ
console.log("Alice と Charlie は同じ年齢ですか？" + aliceAndCharlie + "ですわ"); // Alice と Charlie は同じ年齢ですか？false ですわ

const person = {
  name: "Alice",
  age: 20,
  hobbies: ["reading", "writing", "singing"],
}; // Alice という名前で 20 歳で趣味が読書と執筆と歌唱のオブジェクト

const transform = {
  // 変換関数を定義するオブジェクト
  name: R.toUpper, // name プロパティには大文字にする関数を適用する
  age: R.add(1), // age プロパティには 1 を足す関数を適用する
  hobbies: R.append("dancing"), // hobbies プロパティにはダンスを追加する関数を適用する
};
const newPerson = R.evolve(transform, person); // evolve 関数に変換関数と元のオブジェクトを渡す
console.log("変換前のオブジェクトは" + JSON.stringify(person) + "ですわ"); // 変換前のオブジェクトは{"name":"Alice","age":20,"hobbies":["reading","writing","singing"]}ですわ
console.log("変換後のオブジェクトは" + JSON.stringify(newPerson) + "ですわ"); // 変換後のオブジェクトは{"name":"ALICE","age":21,"hobbies":["reading","writing","singing","dancing"]}ですわ

// オブジェクトを作りますわ
const animals: { [key: string]: string } = {
  dog: "woof",
  cat: "meow",
  cow: "moo",
};
 
// forEachObjIndexed 関数を使って、オブジェクトの各要素に「と鳴く」をつけて表示しますわ
const addSound = (value: string, key: string): void =>
  console.log(key + "は" + value + "と鳴きますわ");
R.forEachObjIndexed(addSound, animals);

dog は woof と鳴きますわ
cat は meow と鳴きますわ
cow は moo と鳴きますわ

// has 関数を使って、オブジェクトに name プロパティが存在するかどうかを判定する
const obj: { name: string; age: number } = { name: "Alice", age: 20 };
const result: boolean = R.has("name", obj);
 
// 結果を確認する
console.log(result); // true

// has 関数に name を渡して、新しい関数を作る
const hasName: (obj: any) => boolean = R.has("name");
 
// 新しい関数にオブジェクトを渡して、name プロパティが存在するかどうかを判定する
const obj: { name: string; age: number } = { name: "Alice", age: 20 };
const result: boolean = hasName(obj);
 
// 結果を確認する
console.log(result); // true

// hasIn関数を使って、オブジェクトにtoStringプロパティが存在するかどうかを判定する
const obj: { name: string; age: number } = { name: "Alice", age: 20 };
const result: boolean = R.hasIn("toString", obj);
 
// 結果を確認する
console.log(result); // true

// hasIn関数にtoStringを渡して、新しい関数を作る
const hasToString: (obj: any) => boolean = R.hasIn("toString");
 
// 新しい関数にオブジェクトを渡して、toStringプロパティが存在するかどうかを判定する
const obj: { name: string; age: number } = { name: "Alice", age: 20 };
const result: boolean = hasToString(obj);
 
// 結果を確認する
console.log(result); // true

// hasPath 関数を使って、オブジェクトに a.b.c プロパティが存在するかどうかを判定する
const obj: { a: { b: { c: number } } } = { a: { b: { c: 42 } } };
const result: boolean = R.hasPath(["a", "b", "c"], obj);
 
// 結果を確認する
console.log(result); // true

// hasPath 関数に["a", "b", "c"]を渡して、新しい関数を作る
const hasABC: (obj: any) => boolean = R.hasPath(["a", "b", "c"]);
 
// 新しい関数にオブジェクトを渡して、a.b.c プロパティが存在するかどうかを判定する
const obj: { a: { b: { c: number } } } = { a: { b: { c: 42 } } };
const result: boolean = hasABC(obj);
 
// 結果を確認する
console.log(result); // true

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

// ramda.js の invertObj 関数をインポートする
import { invertObj } from "ramda";
 
// オブジェクトを用意する
const obj: Record<string, any> = { a: { x: 1, y: 2 }, b: { z: 3 } };
 
// invertObj 関数にオブジェクトを渡す
const newObj: Record<any, string> = invertObj(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

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

type Person = {
  name: string;
  age: number;
};
 
type Student = Person & {
  grade: number;
};
 
const alice: Student = {
  name: "Alice",
  age: 18,
  grade: 3,
};

const keys = keysIn(alice);
console.log(keys); // ["name", "age", "grade"]と表示されますわ

const showPairs = (obj: object): void => {
  const keys = keysIn(obj);
  keys.forEach((key) => {
    console.log(`${key}: ${obj[key]}`); // プロパティと値を表示しますわ
  });
};
 
showPairs(alice); // name: Alice, age: 18, grade: 3 と表示されますわ

type Person = {
  name: string;
  age: number;
  address: {
    city: string;
    zip: string;
  };
};
 
const alice: Person = {
  name: "Alice",
  age: 25,
  address: {
    city: "Tokyo",
    zip: "100-0000",
  },
};

const nameLens = lens(
  (person: Person): string => person.name, // getter 関数
  (name: string, person: Person): Person => ({ ...person, name }) // setter 関数
);

const name = view(nameLens, alice); // Alice と表示されますわ
console.log(name);
 
const bob = set(nameLens, "Bob", alice); // name プロパティを Bob に変更した新しいオブジェクトを返しますわ
console.log(bob);
 
const upperCase = over(nameLens, toUpper, alice); // name プロパティを大文字に変更した新しいオブジェクトを返しますわ
console.log(upperCase);

const colors: string[] = ["red", "green", "blue"];

const firstLens = lensIndex(0);

const first = view(firstLens, colors); // red と表示されますわ
console.log(first);
 
const newColors = set(firstLens, "pink", colors); // 0 番目の要素を pink に変更した新しい配列を返しますわ
console.log(newColors);
 
const upperCase = over(firstLens, toUpper, colors); // 0 番目の要素を大文字に変更した新しい配列を返しますわ
console.log(upperCase);

const user: { name: string; address: { city: string; zipcode: string } } = {
  name: "Alice",
  address: {
    city: "Tokyo",
    zipcode: "100-0000",
  },
};

const zipcodeLens = lensPath(["address", "zipcode"]);

const zipcode = view(zipcodeLens, user); // 100-0000と表示されますわ
console.log(zipcode);
 
const newUser = set(zipcodeLens, "200-0000", user); // address.zipcodeプロパティを200-0000に変更した新しいオブジェクトを返しますわ
console.log(newUser);
 
const addPrefix = over(zipcodeLens, (z: string) => "〒" + z, user); // address.zipcodeプロパティに〒を付け加えた新しいオブジェクトを返しますわ
console.log(addPrefix);

const user: { name: string; age: number } = {
  name: "Alice",
  age: 20,
};

const ageLens = lensProp("age");

const age = view(ageLens, user); // 20 と表示されますわ
console.log(age);
 
const newUser = set(ageLens, 21, user); // age プロパティを 21 に変更した新しいオブジェクトを返しますわ
console.log(newUser);
 
const incrementAge = over(ageLens, (a: number) => a + 1, user); // age プロパティを 1 増やした新しいオブジェクトを返しますわ
console.log(incrementAge);

const scores = {
  Alice: 80,
  Bob: 90,
  Charlie: 95,
};

import { mapObjIndexed } from "ramda";
 
// キーと値を結合して文字列にする関数
const joinKeyValue = (value: number, key: string): string => `${key}: ${value}`;
 
// mapObjIndexed関数を使って新しいオブジェクトを作る
const newScores = mapObjIndexed(joinKeyValue, scores);
 
// 結果を確認する
console.log(newScores); // { Alice: "Alice: 80", Bob: "Bob: 90", Charlie: "Charlie: 95" }

const obj1 = {
  name: "Alice",
  age: 20,
  hobbies: ["reading", "writing"],
  address: {
    city: "Tokyo",
    zip: "123-4567",
  },
};
 
const obj2 = {
  name: "Bob",
  age: 25,
  hobbies: ["singing", "dancing"],
  address: {
    country: "Japan",
    zip: "765-4321",
  },
};

import * as R from "ramda";
 
const obj1 = {
  name: "Alice",
  age: 20,
  hobbies: ["reading", "writing"],
  address: {
    city: "Tokyo",
    zip: "123-4567",
  },
};
 
const obj2 = {
  name: "Bob",
  age: 25,
  hobbies: ["singing", "dancing"],
  address: {
    country: "Japan",
    zip: "765-4321",
  },
};
 
const mergeDeepLeftObj = (
  objA: Record<string, any>,
  objB: Record<string, any>
): Record<string, any> => {
  return R.mergeDeepLeft(objA, objB);
};
 
console.log(mergeDeepLeftObj(obj1, obj2)); // {name: "Alice", age: 20, hobbies: ["reading", "writing", "singing", "dancing"], address: {city: "Tokyo", country: "Japan", zip: "123-4567"}}

const obj1 = {
  name: "Alice",
  age: 21,
  hobbies: ["reading", "cooking"],
  address: {
    city: "Tokyo",
    zip: "100-0000",
  },
};
 
const obj2 = {
  name: "Bob",
  age: 22,
  hobbies: ["gaming", "coding"],
  address: {
    city: "Osaka",
    zip: "500-0000",
  },
};

// mergeDeepRight 関数にオブジェクトを渡してマージする
const mergedObj = R.mergeDeepRight(obj1, obj2);
 
// マージした結果を確認する
console.log(mergedObj);
// { name: 'Bob', age: 22, hobbies: [ 'reading', 'cooking', 'gaming', 'coding' ], address: { city: 'Osaka', zip: '500-0000' } }

const obj1 = {
  name: "Alice",
  age: 21,
  hobbies: ["reading", "cooking"],
  address: {
    city: "Tokyo",
    zip: "100-0000",
  },
};
 
const obj2 = {
  name: "Bob",
  age: 22,
  hobbies: ["gaming", "coding"],
  address: {
    city: "Osaka",
    zip: "500-0000",
  },
};

// マージする際のルールを定義した関数
const mergeRule = (val1: any, val2: any): any => {
  // 値が配列であれば、連結して返す
  if (Array.isArray(val1) && Array.isArray(val2)) {
    return val1.concat(val2);
  }
  // 値がプリミティブ型であれば、val1 の値を返す
  return val1;
};
 
// mergeDeepWith 関数にルールとオブジェクトを渡してマージする
const mergedObj = R.mergeDeepWith(mergeRule, obj1, obj2);
 
// マージした結果を確認する
console.log(mergedObj);
// { name: 'Alice', age: 21, hobbies: [ 'reading', 'cooking', 'gaming', 'coding' ], address: { city: 'Tokyo', zip: '100-0000' } }

const obj1 = {
  name: "Alice",
  age: 21,
  hobbies: ["reading", "cooking"],
  address: {
    city: "Tokyo",
    zip: "100-0000",
  },
};
 
const obj2 = {
  name: "Bob",
  age: 22,
  hobbies: ["gaming", "coding"],
  address: {
    city: "Osaka",
    zip: "500-0000",
  },
};

// マージする際に使う関数を定義する
const mergeFn = (key: string, val1: any, val2: any): any => {
  // キーが name や age などのプリミティブ型の場合
  if (typeof val1 === "string" || typeof val1 === "number") {
    // obj1 と obj2 の値をハイフンでつなげる
    return `${val1}-${val2}`;
  }
  // キーが hobbies などの配列の場合
  if (Array.isArray(val1)) {
    // obj1 と obj2 の配列を連結する
    return [...val1, ...val2];
  }
  // 上記以外の場合はデフォルトのマージ処理を行う
  return R.mergeDeepRight(val1, val2);
};
 
// mergeDeepWithKey 関数にマージする関数とオブジェクトを渡してマージする
const mergedObj = R.mergeDeepWithKey(mergeFn, obj1, obj2);
 
// マージした結果を確認する
console.log(mergedObj);
// { name: 'Alice-Bob', age: '21-22', hobbies: [ 'reading', 'cooking', 'gaming', 'coding' ], address: { city: 'Tokyo-Osaka', zip: '100-0000-500-0000' } }

// 二つのオブジェクトを定義しますわ
const person1 = { name: "Alice", age: 21, hobby: "tennis" };
const person2 = { name: "Bob", age: 23, hobby: "soccer", job: "engineer" };
 
// mergeLeft関数をインポートしますわ
import { mergeLeft } from "ramda";
 
// mergeLeft関数を使って二つのオブジェクトをマージしますわ
const merged = mergeLeft(person1, person2);
 
// 結果を表示しますわ
console.log(merged); // {name: "Alice", age: 21, hobby: "tennis", job: "engineer"}

// オブジェクトのプロパティを更新する関数を定義しますわ
const updateProperty = (key: string, value: any) => (obj: object) =>
  mergeLeft({ [key]: value }, obj);
 
// デフォルト値を設定する関数を定義しますわ
const setDefault = (key: string, value: any) => (obj: object) =>
  mergeLeft(obj, { [key]: value });
 
// 人物のオブジェクトを定義しますわ
const person = { name: "Alice", age: 21 };
 
// updateProperty関数でhobbyプロパティを更新しますわ
const updated = updateProperty("hobby", "tennis")(person);
 
// setDefault関数でjobプロパティにデフォルト値を設定しますわ
const defaulted = setDefault("job", "student")(person);
 
// 結果を表示しますわ
console.log(updated); // {name: "Alice", age: 21, hobby: "tennis"}
console.log(defaulted); // {name: "Alice", age: 21, job: "student"}

// 二つのオブジェクトを定義しますわ
const person1 = { name: "Alice", age: 21, hobby: "tennis" };
const person2 = { name: "Bob", age: 23, hobby: "soccer", job: "engineer" };
 
// mergeRight 関数をインポートしますわ
import { mergeRight } from "ramda";
 
// mergeRight 関数を使って二つのオブジェクトをマージしますわ
const merged = mergeRight(person1, person2);
 
// 結果を表示しますわ
console.log(merged); // {name: "Bob", age: 23, hobby: "soccer", job: "engineer"}

// オブジェクトのプロパティを上書きする関数を定義しますわ
const overwriteProperty = (key: string, value: any) => (obj: object) =>
  mergeRight(obj, { [key]: value });
 
// 新しい値を追加する関数を定義しますわ
const addNewValue = (key: string, value: any) => (obj: object) =>
  mergeRight({ [key]: value }, obj);
 
// 人物のオブジェクトを定義しますわ
const person = { name: "Alice", age: 21 };
 
// overwriteProperty 関数で name プロパティを上書きしますわ
const overwritten = overwriteProperty("name", "Bob")(person);
 
// addNewValue 関数で job プロパティに新しい値を追加しますわ
const added = addNewValue("job", "engineer")(person);
 
// 結果を表示しますわ
console.log(overwritten); // {name: "Bob", age: 21}
console.log(added); // {name: "Alice", age: 21, job: "engineer"}

const obj1 = {
  name: "Alice",
  age: 21,
  hobbies: ["reading", "cooking"],
};
 
const obj2 = {
  name: "Bob",
  age: 22,
  hobbies: ["gaming", "coding"],
};

// マージする際に使う関数を定義する
const mergeFn = (val1: any[], val2: any[]): any[] => {
  // obj1 と obj2 の配列を連結する
  return [...val1, ...val2];
};
 
// mergeWith 関数にマージする関数とオブジェクトを渡してマージする
const mergedObj = R.mergeWith(mergeFn, obj1, obj2);
 
// マージした結果を確認する
console.log(mergedObj);
// { name: 'Bob', age: 22, hobbies: [ 'reading', 'cooking', 'gaming', 'coding' ] }

const obj1 = { name: "Alice", age: 21, hobbies: ["reading", "cooking"] };
const obj2 = { name: "Bob", age: 23, hobbies: ["gaming", "coding"] };

import \* as R from "ramda";
 
// キーと値に応じてマージする関数
const mergeFunc = (key: string, val1: any, val2: any): any => {
if (key === "name") {
return val1; // 最初のオブジェクトの値を優先
} else if (key === "age") {
return (val1 + val2) / 2; // 平均値を取る
} else if (key === "hobbies") {
return R.concat(val1, val2); // 配列を結合する
} else {
return R.concat(val1, val2); // デフォルトは配列を結合する
}
};
 
// mergeWithKey 関数にマージする関数とオブジェクトを渡す
const mergedObj = R.mergeWithKey(mergeFunc, obj1, obj2);
 
// 結果を表示する
console.log(mergedObj);
// {name: "Alice", age: 22, hobbies: ["reading", "cooking", "gaming", "coding"]}

// オブジェクトを受け取って年齢を 1 増やす関数
const incrementAge = (obj: {
  name: string;
  age: number;
}): { name: string; age: number } => R.modify("age", R.inc, obj);
 
// オブジェクトを作成する
const alice = { name: "Alice", age: 20 };
 
// modify 関数を使って年齢を 1 増やす
const alice2 = incrementAge(alice);
 
// 結果を表示する
console.log(alice); // {name: 'Alice', age: 20}
console.log(alice2); // {name: 'Alice', age: 21}

// オブジェクトを受け取って名前の先頭に'Ms.'を付ける関数
const addMs = (obj: {
  name: string;
  age: number;
}): { name: string; age: number } => R.modify("name", R.concat("Ms. "), obj);
 
// オブジェクトを作成する
const bob = { name: "Bob", age: 25 };
 
// modify 関数を使って名前の先頭に'Ms.'を付ける
const bob2 = addMs(bob);
 
// 結果を表示する
console.log(bob); // {name: 'Bob', age: 25}
console.log(bob2); // {name: 'Ms. Bob', age: 25}

// 変更する関数として、文字列を大文字にする関数を定義する
const toUpper = (str: string): string => str.toUpperCase();
 
// オブジェクトの name プロパティの値を大文字にする
const modifyName = R.modifyPath(["name"], toUpper, { name: "Alice", age: 25 }); // {name: "ALICE", age: 25}
 
// オブジェクトの friends プロパティの配列の最初の要素の name プロパティの値を大文字にする
const modifyFriendName = R.modifyPath(["friends", 0, "name"], toUpper, {
  name: "Alice",
  age: 25,
  friends: [
    { name: "Bob", age: 23 },
    { name: "Charlie", age: 24 },
  ],
}); // {name: "Alice", age: 25, friends: [{name: "BOB", age: 23}, {name: "Charlie", age: 24}]}
 
// 変更した結果を確認する
console.log(modifyName); // {name: "ALICE", age: 25}
console.log(modifyFriendName); // {name: "Alice", age: 25, friends: [{name: "BOB", age: 23}, {name: "Charlie", age: 24}]}

const person = { name: "Alice", age: 21, gender: "female" };
console.log(person); // {name: 'Alice', age: 21, gender: 'female'}

const person = { name: "Alice", age: 21, gender: "female" };
console.log(R.omit(["gender"], person)); // {name: 'Alice', age: 21}

const person = {
  name: "Alice",
  age: 21,
  gender: "female",
  address: { city: "Tokyo", zipCode: "100-0000" },
};
console.log(R.omit(["age", "address.zipCode"], person)); // {name: 'Alice', gender: 'female', address:{city:'Tokyo'}}

type Person = {
  name: string;
  age: number;
};
 
const alice: Person = { name: "Alice", age: 21 };
const bob: Person = { name: "Bob", age: 23 };
 
const incAge = (age: number): number => age + 1;
const decAge = (age: number): number => age - 1;
 
console.log(R.over(R.lensProp("age"), incAge, alice)); // { name: 'Alice', age: 22 }
console.log(R.over(R.lensProp("age"), decAge, bob)); // { name: 'Bob', age: 22 }

type Point = [number, number];
 
const origin: Point = [0, 0];
const pointA: Point = [1, 2];
const pointB: Point = [3, 4];
 
const doubleX = (x:number):number => x \* 2;
const halfY = (y:number):number => y / 2;
 
console.log(R.over(R.lensIndex(0), doubleX, origin)); // [0, 0]
console.log(R.over(R.lensIndex(0), doubleX, pointA)); // [2, 2]
console.log(R.over(R.lensIndex(1), halfY, pointB)); // [3, 2]

const person: { name: string; address: { city: string; zipCode: number } } = {
  name: "Alice",
  address: {
    city: "Tokyo",
    zipCode: 1000000,
  },
};
 
console.log(person); // {name:"Alice",address:{city:"Tokyo",zipCode:1000000}}

const getCity = R.path(["address", "city"]);
 
const city = getCity(person);
 
console.log(city); // Tokyo

const getCountry = R.path(["address", "country"]);
 
const country = getCountry(person);
 
console.log(country); // undefined

const person: { name: string; age: number } = {
  name: "Alice",
  age: 25,
};
 
console.log(person); // {name:"Alice",age:25}

const flippedPerson = R.invertObj(person);
 
console.log(flippedPerson); // {"Alice":"name","25":"age"}

const colors: { red: string; green: string; blue: string } = {
  red: "apple",
  green: "pear",
  blue: "apple",
};
 
console.log(colors); // {red:"apple",green:"pear",blue:"apple"}
 
const flippedColors = R.invertObj(colors);
 
console.log(flippedColors); // {"apple":"blue","pear":"green"}

// 人物のオブジェクト
const person = {
  name: "Alice",
  age: 25,
  address: {
    city: "Tokyo",
    country: "Japan",
  },
};
 
// pathOr関数をインポート
import { pathOr } from "ramda";
 
// personオブジェクトから名前を取得する関数
const getName = (obj: object): string => pathOr("Unknown", ["name"], obj);
 
// personオブジェクトから住所の国名を取得する関数
const getCountry = (obj: object): string =>
  pathOr("Unknown", ["address", "country"], obj);
 
// personオブジェクトから趣味を取得する関数
const getHobby = (obj: object): string => pathOr("Unknown", ["hobby"], obj);
 
// 関数を実行して結果を表示
console.log(getName(person)); // Aliceと表示されますわ。
console.log(getCountry(person)); // Japanと表示されますわ。
console.log(getHobby(person)); // Unknownと表示されますわ。

// 人物のオブジェクト
const person = {
  name: "Bob",
  age: 30,
  address: {
    city: "New York",
    country: "USA",
  },
  hobbies: ["reading", "gaming", "cooking"],
};
 
// paths 関数をインポート
import { paths } from "ramda";
 
// person オブジェクトから名前と住所の国名と趣味の最初の要素を取得する関数
const getInfo = (obj: object): (string | undefined)[] =>
  paths([["name"], ["address", "country"], ["hobbies", 0]], obj);
 
// 関数を実行して結果を表示
console.log(getInfo(person)); // ["Bob", "USA", "reading"]と表示されますわ。

import { pick } from "ramda";
 
// 人物のオブジェクトを作成する関数ですわ
const createPerson = (
  name: string,
  age: number,
  gender: string
): { name: string; age: number; gender: string } => {
  return { name, age, gender };
};
 
// 人物のオブジェクトを 3 つ作成しますわ
const alice = createPerson("Alice", 25, "female");
const bob = createPerson("Bob", 30, "male");
const charlie = createPerson("Charlie", 35, "male");
 
// pick 関数で名前と年齢だけを取り出しますわ
const pickNameAndAge = pick(["name", "age"]);
 
// 新しいオブジェクトが作られますわ
const aliceNameAndAge = pickNameAndAge(alice);
const bobNameAndAge = pickNameAndAge(bob);
const charlieNameAndAge = pickNameAndAge(charlie);
 
// 結果を表示しますわ
console.log("Alice の名前と年齢は？");
console.log(aliceNameAndAge); // { name: 'Alice', age: 25 }
console.log("Bob の名前と年齢は？");
console.log(bobNameAndAge); // { name: 'Bob', age: 30 }
console.log("Charlie の名前と年齢は？");
console.log(charlieNameAndAge); // { name: 'Charlie', age: 35 }

import { pickAll } from "ramda";
 
// 人物のオブジェクトを作成する関数ですわ
const createPerson = (
  name: string,
  age: number,
  gender: string
): { name: string; age: number; gender: string } => {
  return { name, age, gender };
};
 
// 人物のオブジェクトを3つ作成しますわ
const alice = createPerson("Alice", 25, "female");
const bob = createPerson("Bob", 30, "male");
const charlie = createPerson("Charlie", 35, "male");
 
// pickAll関数で名前と年齢と趣味を取り出しますわ
const pickNameAndAgeAndHobby = pickAll(["name", "age", "hobby"]);
 
// 新しいオブジェクトが作られますが、趣味はundefinedになりますわ
const aliceNameAndAgeAndHobby = pickNameAndAgeAndHobby(alice);
const bobNameAndAgeAndHobby = pickNameAndAgeAndHobby(bob);
const charlieNameAndAgeAndHobby = pickNameAndAgeAndHobby(charlie);
 
// 結果を表示しますわ
console.log("Aliceの名前と年齢と趣味は？");
console.log(aliceNameAndAgeAndHobby); // { name: 'Alice', age: 25, hobby: undefined }
console.log("Bobの名前と年齢と趣味は？");
console.log(bobNameAndAgeAndHobby); // { name: 'Bob', age: 30, hobby: undefined }
console.log("Charlieの名前と年齢と趣味は？");
console.log(charlieNameAndAgeAndHobby); // { name: 'Charlie', age: 35, hobby: undefined }

import { pickBy } from "ramda";
 
// プロパティのキーが特定の文字列で始まるかどうかを判定する関数ですわ
const startsWith =
  (prefix: string) =>
  (value: any, key: string): boolean =>
    key.startsWith(prefix);
 
// 人物のオブジェクトを作成する関数ですわ
const createPerson = (
  name: string,
  age: number,
  gender: string
): { name: string; age: number; gender: string } => {
  return { name, age, gender };
};
 
// 人物のオブジェクトを3つ作成しますわ
const alice = createPerson("Alice", 25, "female");
const bob = createPerson("Bob", 30, "male");
const charlie = createPerson("Charlie", 35, "male");
 
// pickBy関数で名前がAで始まる人物だけを取り出しますわ
const pickPeopleWithNameStartingWithA = pickBy(startsWith("A"));
 
// 新しいオブジェクトが作られますが、名前がAで始まらない人物は無視されますわ
const peopleWithNameStartingWithA = pickPeopleWithNameStartingWithA({
  alice,
  bob,
  charlie,
});
 
// 結果を表示しますわ
console.log("名前がAで始まる人物は？");
console.log(peopleWithNameStartingWithA); // { alice: { name: 'Alice', age: 25, gender: 'female' } }

// 人の名前と年齢を持つオブジェクトの配列
const people: { name: string; age: number }[] = [
  { name: "Alice", age: 25 },
  { name: "Bob", age: 30 },
  { name: "Charlie", age: 35 },
];
 
// ramda.js の project 関数をインポート
import { project } from "ramda";
 
// project 関数に抽出したいプロパティの配列を渡して新しい関数を作る
const getName = project(["name"]);
 
// getName 関数にオブジェクトの配列を渡して名前だけを抽出する
const names: string[] = getName(people);
 
// 新しい配列をコンソールに出力
console.log("人の名前だけが抽出されましたわ");
console.log(names);

// 年齢だけを抽出する関数
const getAge = project(["age"]);
 
// 年齢だけを抽出する
const ages: number[] = getAge(people);
 
// 新しい配列をコンソールに出力
console.log("人の年齢だけが抽出されましたわ");
console.log(ages);

// 名前と年齢だけを抽出する関数
const getNameAndAge = project(["name", "age"]);
 
// 名前と年齢だけを抽出する
const nameAndAges: { name: string; age: number }[] = getNameAndAge(people);
 
// 新しい配列をコンソールに出力
console.log("人の名前と年齢だけが抽出されましたわ");
console.log(nameAndAges);

// オブジェクトの配列
const persons: { name: string; age?: number }[] = [
  { name: "Alice", age: 25 },
  { name: "Bob" },
  { name: "Charlie", age: 30 },
];

// ramda.js の propOr 関数と map 関数をインポート
import { propOr, map } from "ramda";
 
// 年齢が存在する場合はその値を、存在しない場合は"unknown"という文字列を返す関数
const getAgeOrUnknown = propOr("unknown", "age");
 
// 配列から年齢または"unknown"を取り出す
const ages = map(getAgeOrUnknown, persons);
 
// 年齢または"unknown"をコンソールに出力
console.log("年齢はこちらですわ");
console.log(ages);

// 名前が存在する場合はその値を、存在しない場合は"anonymous"という文字列を返す関数
const getNameOrAnonymous = propOr("anonymous", "name");
 
// 配列から名前または"anonymous"を取り出す
const names = map(getNameOrAnonymous, persons);
 
// 名前または"anonymous"をコンソールに出力
console.log("名前はこちらですわ");
console.log(names);

// オブジェクトの配列を作りますわ
const people = [
  { name: "Alice", age: 25, gender: "female" },
  { name: "Bob", age: 30, gender: "male" },
  { name: "Charlie", age: 35, gender: "male" },
];
 
// props関数を使って、名前と年齢の配列を取り出しますわ
const namesAndAges = R.props(["name", "age"]);
console.log(namesAndAges(people[0])); // ["Alice", 25]
console.log(namesAndAges(people[1])); // ["Bob", 30]
console.log(namesAndAges(people[2])); // ["Charlie", 35]
 
// props関数はカリー化されているので、部分適用もできますわ
const getNames = R.props(["name"]);
console.log(getNames(people[0])); // ["Alice"]
console.log(getNames(people[1])); // ["Bob"]
console.log(getNames(people[2])); // ["Charlie"]

// set 関数のインポート
import { set } from "ramda";
 
// オブジェクトの定義
const person = {
  name: "Alice",
  age: 25,
  address: {
    city: "Tokyo",
    zip: "100-0000",
  },
};
 
// set 関数で name プロパティを更新する
const newName = set("name", "Bob", person);
 
// 結果を確認する
console.log(newName); // {name: "Bob", age: 25, address: {city: "Tokyo", zip: "100-0000"}}
console.log(person); // {name: "Alice", age: 25, address: {city: "Tokyo", zip: "100-0000"}}
 
// set 関数で address.city プロパティを更新する
const newCity = set(["address", "city"], "Osaka", person);
 
// 結果を確認する
console.log(newCity); // {name: "Alice", age: 25, address: {city: "Osaka", zip: "100-0000"}}
console.log(person); // {name: "Alice", age: 25, address: {city: "Tokyo", zip:"100-0000"}}

const data: { name: string; hobbies: string[] }[] = [
  { name: "Alice", hobbies: ["reading", "writing"] },
  { name: "Bob", hobbies: ["gaming", "coding"] },
  { name: "Charlie", hobbies: ["cooking", "baking"] },
];

import R from "ramda";
 
// hobbies キーに対応する配列の要素を展開する
const result = R.unwind("hobbies")(data);
 
// 結果を確認する
console.log(result); // [{name:"Alice",hobbies:"reading"},{name:"Alice",hobbies:"writing"},{name:"Bob",hobbies:"gaming"},{name:"Bob",hobbies:"coding"},{name:"Charlie",hobbies:"cooking"},{name:"Charlie",hobbies:"baking"}]

const data: { id: number; values: number[] }[] = [
  { id: 1, values: [10, 20] },
  { id: 2, values: [30, 40] },
  { id: 3, values: [50, 60] },
];

import R from "ramda";
 
// values キーに対応する配列の要素を展開する
const result = R.unwind("values")(data);
 
// 結果を確認する
console.log(result); // [{id:1,values:10},{id:1,values:20},{id:2,values:30},{id:2,values:40},{id:3,values:50},{id:3,values:
60}]

// 人物の情報を表すオブジェクト
const person = {
  name: "Alice",
  age: 25,
  gender: "female",
};

import R from "ramda";
 
// values 関数で person オブジェクトの値を配列として取得する
const values = R.values(person);
 
// 結果を確認する
console.log(values); // ["Alice", 25, "female"]

// 国名と首都名を表すマップ
const countries = new Map<string, string>([
  ["Japan", "Tokyo"],
  ["France", "Paris"],
  ["USA", "Washington"],
]);