package cats

import simulacrum.{noop, typeclass}

/**
 * Functor.
 *
 * The name is short for "covariant functor".
 *
 * Must obey the laws defined in cats.laws.FunctorLaws.
 */
@typeclass trait Functor[F[_]] extends Invariant[F] { self =>
  def map[A, B](fa: F[A])(f: A => B): F[B]
  ...
}

// Identity.ts

import { Functor1 } from "fp-ts/lib/Functor";

export const URI = "Identity";

export type URI = typeof URI;

declare module "fp-ts/lib/HKT" {
  interface URItoKind<A> {
    readonly Identity: Identity<A>;
  }
}

export type Identity<A> = A;

// Functor instance
export const identity: Functor1<URI> = {
  URI,
  map: (ma, f) => f(ma),
};

// fp-ts/lib/Functor.ts

export interface Functor1<F extends URIS> {
  readonly URI: F;
  readonly map: <A, B>(fa: Kind<F, A>, f: (a: A) => B) => Kind<F, B>;
}

// fp-ts/lib/HKT.ts

export interface URItoKind<A> {}

// Identity.ts

declare module "fp-ts/lib/HKT" {
  interface URItoKind<A> {
    readonly Identity: Identity<A>; // maps the key "Identity" to the type `Identity`
  }
}

// Either.ts

import { Functor2 } from "fp-ts/lib/Functor";

export const URI = "Either";

export type URI = typeof URI;

declare module "fp-ts/lib/HKT" {
  interface URItoKind2<E, A> {
    readonly Either: Either<E, A>;
  }
}

export interface Left<E> {
  readonly _tag: "Left";
  readonly left: E;
}

export interface Right<A> {
  readonly _tag: "Right";
  readonly right: A;
}

export type Either<E, A> = Left<E> | Right<A>;

// Functor instance
export const either: Functor2<URI> = {
  URI,
  map: (ma, f) => (ma._tag === "Left" ? ma : right(f(ma.right))),
};

// fp-ts/lib/Functor.ts

export interface Functor2<F extends URIS2> {
  readonly URI: F;
  readonly map: <E, A, B>(fa: Kind2<F, E, A>, f: (a: A) => B) => Kind2<F, E, B>;
}

import { HKT } from "fp-ts/lib/HKT";

export function lift<F>(
  F: Functor<F>
): <A, B>(f: (a: A) => B) => (fa: HKT<F, A>) => HKT<F, B> {
  return (f) => (fa) => F.map(fa, f);
}

// fp-ts/lib/HKT.ts

export interface HKT<URI, A> {
  readonly _URI: URI;
  readonly _A: A;
}

const double = (n: number): number => n * 2;

//                             v-- the Functor instance of Identity
const doubleIdentity = lift(identity)(double);

Argument of type 'Functor1<"Identity">' is not assignable to parameter of type 'Functor<"Identity">'

export function lift<F extends URIS2>(
  F: Functor2<F>
): <A, B>(f: (a: A) => B) => <E>(fa: Kind2<F, E, A>) => Kind2<F, E, B>;
export function lift<F extends URIS>(
  F: Functor1<F>
): <A, B>(f: (a: A) => B) => (fa: Kind<F, A>) => Kind<F, B>;
export function lift<F>(
  F: Functor<F>
): <A, B>(f: (a: A) => B) => (fa: HKT<F, A>) => HKT<F, B>;
export function lift<F>(
  F: Functor<F>
): <A, B>(f: (a: A) => B) => (fa: HKT<F, A>) => HKT<F, B> {
  return (f) => (fa) => F.map(fa, f);
}

// `doubleIdentity` has type `(fa: Identity<number>) => Identity<number>`
const doubleIdentity = lift(identity)(double);

// `doubleEither` has type `<E>(fa: Either<E, number>) => Either<E, number>`
const doubleEither = lift(either)(double);

Prelude> :k Either
Either :: * -> * -> *
Prelude> :k Either String
Either String :: * -> *
Prelude> :k Either String Int
Either String Int :: *

scala> :k Int
Int's kind is A

scala> :k Either
Either's kind is F[+A1,+A2]

scala> :k Option
Option's kind is F[+A]

scala> type IntOrA[A] = Either[Int, A]
defined type alias IntOrA

scala> :k IntOrA
IntOrA's kind is F[A]

// 再掲
export function lift<F extends URIS2>(
  F: Functor2<F>
): <A, B>(f: (a: A) => B) => <E>(fa: Kind2<F, E, A>) => Kind2<F, E, B>;
export function lift<F extends URIS>(
  F: Functor1<F>
): <A, B>(f: (a: A) => B) => (fa: Kind<F, A>) => Kind<F, B>;
export function lift<F>(
  F: Functor<F>
): <A, B>(f: (a: A) => B) => (fa: HKT<F, A>) => HKT<F, B>;
export function lift<F>(
  F: Functor<F>
): <A, B>(f: (a: A) => B) => (fa: HKT<F, A>) => HKT<F, B> {
  return (f) => (fa) => F.map(fa, f);
}

export interface URItoKind<S, R, E> {
  Effect: Effect<R, E, A>; // * -> * -> * -> *　な型の一例
  Either: Either<E, A>; // * -> * -> *　な型の一例
  Option: Option<A>; // * -> * な型の一例
}

export type URIS = keyof URItoKind<any, any, any, any>;

export type Kind<F extends URIS, S, R, E, A> = URItoKind<S, R, E, A>[F];

export interface Functor<F extends URIS> {
  URI: F;
  map: <A, A2>(
    f: (a: A) => A2
  ) => <S, R, E>(fa: Kind<F, S, R, E, A>) => Kind<F, S, R, E, A2>;
}

export function lift<F extends URIS>(
  F: Functor<F>
): <S, R, E, A, B>(
  f: (a: A) => B
) => (fa: Kind<F, S, R, E, A>) => Kind<F, S, R, E, A> {
  return (f) => (fa) => F.map(f)(fa);
}

// EqInstances.scala
object EqInstances {
  // `implicit val` というキーワードで `Eq` のインスタンスを定義する
  implicit val catEq: Eq[Cat] =
    Eq[Cat] { (cat1, cat2) =>
      cat1.name === cat2.name && cat1.age === cat2.age && cat1.color === cat2.color
    }

  implicit val dogEq: Eq[Dog] =
    Eq[Dog] { (dog1, dog2) =>
      dog1.cry === dog2.cry
    }
}

// Main.scala
import EqInstances.EqInstances._
import cats.Eq

// コンパイラは、apply[A] の A から、自動的に対応する instance を見つけてくれる
val eqCat = Eq.apply[Cat]
eqCat.eqv(cat1, cat2)
val eqDog = Eq.apply[Dog]
eqDog.eqv(dog1, dog2)

// `eqv` を使いたいだけであれば、インスタンスを作らなくとも operator として`===` が提供されている
// === の実態は `eqv` なので（後述）、やはり自動的に対応する `Eq` の instance を見つけてくれる
// `cat1 === cat2` と書くと `catEq.eqv` が使われるし、`dog1 === dog2` と書くと `dogEq.eqv` が使われる
cat1 === cat2
dog1 === dog2

// eq-instances.ts
export const eqCat: Eq<Cat> = {
  // fp-ts では `eqv` ではなく `equals` という名前のメソッドを定義する
  equals: (cat1, cat2) =>
    cat1.name === cat2.name &&
    cat1.age === cat2.age &&
    cat1.color === cat2.color,
};

export const eqDog: Eq<Dog> = {
  equals: (dog1, dog2) => dog1.cry === dog2.cry,
};

// main.ts
import { eqCat, eqDog } from "eq-instances";

// Eq.apply[Cat] みたいなことはできないので、`eqCat`, `eqDog` をそれぞれ直接 import している
eqCat.equals(cat1, cat2);
eqDog.equals(dog1, dog2);

package Json
// Define a very simple JSON AST
// sealed: 同一ファイル内からのみ継承可能
sealed trait Json
final case class JsObject(get: Map[String, Json]) extends Json
final case class JsString(get: String) extends Json
final case class JsNumber(get: Double) extends Json
final case object JsNull extends Json

// オレオレ型クラス
// The "serialize to JSON" behaviour is encoded in this trait
trait JsonWriter[A] {
  def write(value: A): Json
}

// オレオレ型クラス `JsonWriter` のインスタンスを定義する場所
object JsonWriterInstances {
  // `implicit val` を用いて、`A = String`, `A = Person`, ...のインスタンスを実装している
  implicit val stringWriter: JsonWriter[String] =
    new JsonWriter[String] {
      def write(value: String): Json =
        JsString(value)
    }

  implicit val personWriter: JsonWriter[Person] =
    new JsonWriter[Person] {
      def write(value: Person): Json =
        JsObject(
          Map(
            "name" -> JsString(value.name),
            "email" -> JsString(value.email)
          )
        )
    }

  // `implicit def` を用いることで、`optionWriter` の実装において `JsonWriter[A]` を使うことができる
  implicit def optionWriter[A](implicit
      writer: JsonWriter[A]
  ): JsonWriter[Option[A]] =
    new JsonWriter[Option[A]] {
      def write(option: Option[A]): Json =
        option match {
          case Some(aValue) => writer.write(aValue)
          case None         => JsNull
        }
    }
  // etc...
}

object Json {
  // **implicit parameter** は、ここでいう `w`。
  // 型クラスを扱うメソッドをこれだけで定義できる（`JsonWriter` の `A` の実装はコンパイラが勝手に見つけてくれる）
  def toJson[A](value: A)(implicit w: JsonWriter[A]): Json =
    w.write(value)
}

final case class Person(name: String, email: String)

object Main extends App {
  import JsonWriterInstances._
  // 1. Json.toJson は implicit parameter として `w: JsonWriter[A]` をとる
  // 2. `JsonWriter[A = Person]` の実装を、`implicit val` で `JsonWriterInstances.personWriter` に定義済みのため、コンパイラはそれを見つける
  println(Json.toJson(Person("Dave", "dave@example.com")))
  println(Json.toJson("hello!"))
  println(Json.toJson(Option("Hoge")))
}

import cats.syntax.either._

"Error".asLeft[Int].orElse(2.asRight[String])
// res12: Either[String, Int] = Right(2)

// cats/core/src/main/scala/cats/syntax/either.scala
trait EitherSyntax {
  // 2. implicit def を使うことで、`a: A` を `a: EitherIdOps` にキャストしている
  // これをもって `a` から `asLeft` などの `EitherIdOps` のメソッドが呼び出すことができる
  implicit final def catsSyntaxEitherId[A](a: A): EitherIdOps[A] = new EitherIdOps(a)
}

// 1. `AnyVal` を継承したクラス `EitherIdOps` を定義する
// `EitherIdOps` はコンストラクタの引数に型 `A` の値 `obj` を取る
final class EitherIdOps[A](private val obj: A) extends AnyVal {
  /**
   * Wrap a value in `Left`.
   */
  def asLeft[B]: Either[A, B] = Left(obj)

  /**
   * Wrap a value in `Right`.
   */
  def asRight[B]: Either[B, A] = Right(obj)

  // and more!
}

// cats/syntax/eq.scala
package cats
package syntax

trait EqSyntax {
  implicit def catsSyntaxEq[A: Eq](a: A): EqOps[A] = new EqOps[A](a)
}

final class EqOps[A: Eq](lhs: A) {
  def ===(rhs: A): Boolean = Eq[A].eqv(lhs, rhs)
  def =!=(rhs: A): Boolean = Eq[A].neqv(lhs, rhs)
  def eqv(rhs: A): Boolean = Eq[A].eqv(lhs, rhs)
  def neqv(rhs: A): Boolean = Eq[A].neqv(lhs, rhs)
}

// 使うとき
import cats.syntax.eq._ // for === and =!=
123 === 123
123 =!= 234
// type mismatch;
// 123 === "123"

val x = {
   println("Computing X")
   math.random
 }
 // Computing X
 // x: Double = 0.15241729989551633

 x // first access
 // res0: Double = 0.15241729989551633
 x // second access
 // res1: Double = 0.15241729989551633 <- 一度目の access での評価の結果が記憶されている（Memoization）

 def y = {
   println("Computing Y")
   math.random
 }

 y // first access
 // Computing Y
 // res2: Double = 0.6963618800921411
 y // second access
 // Computing Y
 // res3: Double = 0.7321640587866993 <- 一度目の access での評価の結果は記憶されていない。

 lazy val z = {
   println("Computing Z")
   math.random
 }

 z // first access
 // Computing Z
 // res4: Double = 0.18457255119783122
 z // second access
 // res5: Double = 0.18457255119783122 <- 一度目の access での評価の結果が記憶されている

import cats.Eval

 val x = Eval.now {
   println("Computing X")
   math.random
 }
 // Computing X
 // x: Eval[Double] = Now(0.681816469770503)

 x.value // first access
 // res10: Double = 0.681816469770503
 x.value // second access
 // res11: Double = 0.681816469770503

 val y = Eval.always {
   println("Computing Y")
   math.random
 }
 // y: Eval[Double] = cats.Always@414a351

 y.value // first access
 // Computing Y
 // res12: Double = 0.09982997820703643
 y.value // second access
 // Computing Y
 // res13: Double = 0.34240334819463436

 val z = Eval.later {
   println("Computing Z")
   math.random
 }
 // z: Eval[Double] = cats.Later@b0a344a

 z.value // first access
 // Computing Z
 // res14: Double = 0.3604236919233441
 z.value // second access
 // res15: Double = 0.3604236919233441

val ans = for {
  a <- Eval
    .now { println("Calculating A"); 38 }
    .map(a => { println("map a to a'"); a + 2 })
  b <- Eval
    .always { println("Calculating B"); 1 }
    .map(b => { println("map b to b'"); b + 1 })
} yield {
  println("Adding A and B")
  a + b
}

println(ans.value)
// Calculating A
// map a to a'
// Calculating B
// map b to b'
// Adding A and B
// 42