globulon

(defn problem-fifty-two[]
  (time (take 1 (drop-while #(not (= 1 (count (set (map (comp sort str (partial * %)) [2 3 4 5 6]))))) (iterate inc 1)))))

globulon

package com.promindis.patterns


trait ApplicativeHelper[F[_]] extends MonadHelper[F] {
  def apply[U](data: U): F[U]

  def apply[U](input: F[U]): Applicative[U, F]
}

trait Applicative[+T, F[_]] extends Monad[T, F] {

globulon

package com.promindis.user

import com.promindis.patterns.{ApplicativeHelper, Applicative}

object Applicatives {
  implicit object ApplicativeList extends ApplicativeHelper[List]{
    override def flatten[T](m: List[List[T]]) = m.flatten

    override def apply[U](data: U) = List(data)

globulon

//Check whole project https://github.com/globulon/Scala-Patterns-Experiments

object SM {
  case class State[T, S](f: (S) => (T,S)) {
    def apply(s: S): (T, S) = f(s)
  }

implicit def stateToComprehension[T, S](state: State[T,S]) = new {
  implicit val functor = stateFunctor[S]()
  val monad = stateMonad[S]()

globulon

  implicit def stateFunctor[S]() = new Functor[({type λ[α] = State[α,S]})#λ] {
    def map[T, P >: T, U](source: State[T, S])(f: P => U): State[U, S] = new State[U, S]((s: S) => {
      val (value, state) = source(s)
      (f(value), state)
    })
  }

  implicit def stateMonad[S]() =  new Monad[({type λ[α] = State[α,S]})#λ]{

globulon

trait Functor[M[_]] {
  def map[T,P >: T, U](source: M[T])(f: P => U): M[U];
}

trait Monad[M[_]] {

  def apply[T](data: T): M[T]

  def flatten[T](m: M[M[T]]): M[T]

globulon

s -> (a, s)

newtype State s a = State { runState :: s -> (a, s) }

globulon

case class State[+T, S](f: (S) => (T,S)) {
  def apply(s: S): (T, S) = f(s)
}

globulon

 implicit def stateToComprehension[T, S](state: State[T,S]) = new {
    implicit val functor = stateFunctor[S]()
    val monad = stateMonad[S]()

    def map[U](f: T => U) = functor.map(state)(f)

    def flatMap[U](f: T => State[U, S]) = monad.flatMap(state)(f)
  }

globulon

object Stack {

  def push[Int](x: Int) = new State((state: List[Int]) => ((), x :: state))

  def pop = new State((state: List[Int]) =>
    state match {
      case x :: xs => (Some(x), xs)
      case _ => (None, state)
    }
  )