Edward Huang edwardGunawan

## chooseWithListOfStatement.scala
def choose(checkStatement: Int)(lstOfActions: List[(Int) => Unit]): Unit

## chooseWithTwoBoolean.scala
def choose(checkStatment: Boolean)(ifTrue: =>  Unit, ifFalse: => Unit): Unit

## reduceSemigroup.scala
def reduceSemigroup[A,B, F[_]](as:F[A])(f: A => B)(implicit F: Semigroup[B]): B

## fetchDBWithUnsafeRunSync.scala
val fetchDB: IO[Unit] = IO{
  // some side effect (fetch DB print something)
  fetchDB
}

val res = for {
  _ <- fetchingDB
  _ <- fetchingDB
} yield ()

## fetchDB.scala
val fetchingDB: Future[Unit] = Future{
  // some side effect (fetch DB print something)
  fetchDB
}
for {
  _ <- fetchingDB
  _ <- fetchingDB
} yield ()

## featchAndParseWithType.scala
def fetchAndParse(URL:String, client:Client): IO[Either[ParsingError,Json]]

## fetchAndParse.scala
def fetchAndParse(url:String, client:Client): Json = {
  val res = client.fetch(url)
  parse(res)
}

## handlePrepare.scala
def handlePrepare[V](msg: MessagePrepare[V]): State[Acceptor[V], Action] =
    for {
      acceptor <- State.get[Acceptor[V]]
      (newAcceptor, action) = acceptor.promiseId match {
        case Some(proposalId) if (msg.proposalId < proposalId) => (acceptor, Noop)
        case _ =>
          (
            acceptor.copy(promiseId = Some(msg.proposalId)),
            Send(
              MessagePromise(proposalId = msg.proposalId, acceptor.maybeAccepted)

## Ops.scala
trait LearnerOps {
  def handleAccepted[V](msg: MessageAccepted[V]): State[Learner[V], Unit]
  def getValue[V]: State[Learner[V], Option[V]]
}

trait ProposerOps {
  def sendPrepareProposal[V](message: MessagePrepare[V]): Action
  def handlePromise[V](messages: List[MessagePromise[V]]): State[Proposer[V], Action]
  def handleAccept[V](messages: List[MessageAccepted[V]]): State[Proposer[V], Action]
  def constructHigherProposalId[V](prevProposal: Proposer[V]): Proposer[V]

## func.scala
def func(someArgument:SomeArgument): State[YourState, Action]
	val fetchDB: IO[Unit] = IO{
	// some side effect (fetch DB print something)
	fetchDB
	}

	val res = for {
	_ <- fetchingDB
	_ <- fetchingDB
	} yield ()
	val fetchingDB: Future[Unit] = Future{
	// some side effect (fetch DB print something)
	fetchDB
	}
	for {
	_ <- fetchingDB
	_ <- fetchingDB
	} yield ()
	def fetchAndParse(url:String, client:Client): Json = {
	val res = client.fetch(url)
	parse(res)
	}
	def handlePrepare[V](msg: MessagePrepare[V]): State[Acceptor[V], Action] =
	for {
	acceptor <- State.get[Acceptor[V]]
	(newAcceptor, action) = acceptor.promiseId match {
	case Some(proposalId) if (msg.proposalId < proposalId) => (acceptor, Noop)
	case _ =>
	(
	acceptor.copy(promiseId = Some(msg.proposalId)),
	Send(
	MessagePromise(proposalId = msg.proposalId, acceptor.maybeAccepted)
	trait LearnerOps {
	def handleAccepted[V](msg: MessageAccepted[V]): State[Learner[V], Unit]
	def getValue[V]: State[Learner[V], Option[V]]
	}

	trait ProposerOps {
	def sendPrepareProposal[V](message: MessagePrepare[V]): Action
	def handlePromise[V](messages: List[MessagePromise[V]]): State[Proposer[V], Action]
	def handleAccept[V](messages: List[MessageAccepted[V]]): State[Proposer[V], Action]
	def constructHigherProposalId[V](prevProposal: Proposer[V]): Proposer[V]