ryandavidhartman

def f1(x: Int): Int = x*x

val f2 = (x: Int) => x*x

def f3 = (x: Int) => x*x

def f4:(Int => Int) = x => x*x

ryandavidhartman

def factorial(n: Int) : Int = {
   def factorialTR(acc: Int, n: Int) : Int = if (n == 1) acc else factorialTR(acc * n, n - 1)
   
   factorialTR(1, n)
}

factorial(4) =
factorialTR(1, 4) = 
if (4 == 1) 1 else factorialTR(1 * 4, 4 - 1) =
factorialTR(1 * 4, 4 - 1) =

ryandavidhartman

def factorial(n: Int): Int = if (n == 0) 1 else n * factorial(n - 1)


factorial(4) =
if (4 == 0) 1 else 4 * factorial(4 - 1) = 
4 * factorial(4 - 1) =
4 * factorial(3) = 
4 * { if (3 == 0) 1 else 3 * factorial(3 - 1) } =
4 * { 3 * factorial(3 - 1) } =
4 * { 3 * factorial(2) } =

ryandavidhartman

package com.example.basic

import java.util.Properties
import kafka.consumer.{ConsumerIterator, Consumer, ConsumerConfig, KafkaStream}
import kafka.serializer.StringDecoder
import kafka.utils.VerifiableProperties

case class BasicConsumer(zooKeeper: String, groupId: String, waitTime: String) {

  val kafkaProps = new Properties()

ryandavidhartman

package com.example.basic

import java.util.Properties
import org.apache.kafka.clients.producer.{Callback, RecordMetadata, ProducerRecord, KafkaProducer}

import scala.concurrent.Promise


case class BasicProducer(topic: String, brokerList:String, sync: Boolean) {
  val kafkaProps = new Properties()

ryandavidhartman

trait Future[+T] {

  def flatMap[S](f: T => Future[S])
                (implicit executor: ExecutionContext): Future[S] = {

    val promise = new Promise[S]()

    this.onComplete {

      // The first Future (this) failed

ryandavidhartman

trait Future[+T] extends Awaitable[T] {
  def flatMap[S](f: T => Future[S])(implicit executor: ExecutionContext): Future[S] = {
    import impl.Promise.DefaultPromise
    val p = new DefaultPromise[S]()
    onComplete {
      case f: Failure[_] => p complete f.asInstanceOf[Failure[S]]
      case Success(v) => try f(v) match {
        // If possible, link DefaultPromises to avoid space leaks
        case dp: DefaultPromise[_] => dp.asInstanceOf[DefaultPromise[S]].linkRootOf(p)
        case fut => fut.onComplete(p.complete)(internalExecutor)

ryandavidhartman

case class StoreViewSummaryResponse(
  invoiceData: Iterable[(Invoice, ServiceProvider, Address, ContactInformationData, Sku, Option[String])],
  orderTotal: org.joda.money.Money)

lazy val viewSummary: Service[StoreViewSummaryRequest, StoreViewSummaryResponse] = monitored {
  
  //get data from db as Iterables[T]
  invoice, serviceProviders primaryAddresses, transactionIds   

  // get from remote server (returns a list of Future[Sku] )

ryandavidhartman

object Program {
  def apply(): Program = new Program()
}
 
trait Program {
def collectData(): Try[List[Data]] = {
  val data = dataGetter()
  if(data.length < 1)
    throw new DataException("Data Collection Fails")
  else

ryandavidhartman

def processData(data: Try[List[Data]]): Try[Int] =  for {
  x <- data
  results <- x. x.sumBy(i => i.value)
  } yield results