package scalaz.example

import scalaz._

object ExampleApplicative {
  def main(args: Array[String]) = run

  import Scalaz._

  def run {
    // Apply the List Applicative functor
    ((List(40, 50, 60) <*> (List(1, 2, 3) ∘ ((_: Int) * (_: Int)).curried))) assert_≟ List(40, 50, 60, 80, 100, 120, 120, 150, 180)

    // Lift-2 the List Applicative functor
    List(1, 2, 3).<**>(List(40, 50, 60))(_ * _) assert_≟ List(40, 50, 60, 80, 100, 120, 120, 150, 180)

    // Lift-2 the List Applicative functor to a pair
    (List(1, 2, 3) <|*|> List(40, 50, 60)) assert_≟ List((1, 40), (1, 50), (1, 60), (2, 40), (2, 50), (2, 60), (3, 40), (3, 50), (3, 60))

    // Apply the List Applicative functor with an anonymous right
    (List(1, 2, 3) *> List(40, 50, 60)) assert_≟ List(40, 50, 60, 40, 50, 60, 40, 50, 60)

    // Apply the List Applicative functor with an anonymous left
    (List(1, 2, 3) <* List(40, 50, 60)) assert_≟ List(1, 1, 1, 2, 2, 2, 3, 3, 3)

    {
      // Apply the Function Applicative functor to produce a function that lifts conjunction
      // i.e. x => if(x < 15 && x % 2 == 0) without repeating the application to x.
      val z = ((_: Int) > 15) <*> (((_: Int) % 2 == 0) ∘ ((_: Boolean) ∧ (_: Boolean)).curried)
      
      List(7, 8, 14, 15, 16, 20, 21) ∘ z assert_≟ List(false,false,false,false,true,true,false)
    }

    def s[A](a: A) = a.success[List[String]]
    def f[A](s: String) = ff(List(s))
    def ff[A](s: List[String]) = s.fail[Int]
    val add3 = (x: Int) => (y: Int) => (z: Int) => x + y + z

    s(7) <*> (s(8) <*> (s(9) ∘ add3)) assert_≟ s(24)
    f("bzzt") <*> (s(8) <*> (f("bang") ∘ add3)) assert_≟ ff(List("bang", "bzzt"))

    s(7) *> s(8) assert_≟ s(8)
    s(7) *> f("bzzt") assert_≟ f("bzzt")
    f("bang") *> s(8) assert_≟ f("bang")
    f("bang") *> f("bzzt") assert_≟ ff(List("bang", "bzzt"))

    s(7) <* s(8) assert_≟ s(7)
    s(7) <* f("bzzt") assert_≟ f("bzzt")
    f("bang") <* s(8) assert_≟ f("bang")
    f("bang") <* f("bzzt") assert_≟ ff(List("bang", "bzzt"))

    s(7) <|*|> s(8) assert_≟ s(7, 8)
    s(7) <|*|> f("bzzt") assert_≟ List("bzzt").fail
    f("bang") <|*|> s(8) assert_≟ List("bang").fail
    f("bang") <|*|> f("bzzt") assert_≟ List("bang", "bzzt").fail

    // Using alternative syntax to directly apply a sequence of N applicative
    // arguments to a N-ary function.
    val a, b, c, d = List(1)
    (a ⊛ b){_ + _}
    a ⊛ b apply {_ + _}
    (a ⊛ b ⊛ c){_ + _ + _}
    a ⊛ b ⊛ c apply {_ + _ + _}
    a ⊛ b ⊛ c ⊛ d apply {_ + _ + _ + _}
    a |@| b |@| c |@| d apply {_ + _ + _ + _}

    (a ⊛ b ⊛ c ⊛ d).tupled
    (a |@| b |@| c |@| d).tupled

    case class Person(age: Int, name: String)
    some(10) ⊛ none[String] apply Person.apply
  }
}