monkeygroover

object ScalaJSExample extends js.JSApp{
  def main() = {
    val xs = Seq(1, 2, 3)
    println(xs.toString)
    val ys = Seq(4, 5, 6)
    println(ys.toString)
    val zs = for{
      x <- xs
      y <- ys
    } yield x * y

monkeygroover

import shapeless._
import spray.json._

object Main extends App {

  case class Test(optionalBlah: Option[String])
  case class Test2(nested: Test)

  import DefaultJsonProtocol._
  implicit val testFormat = DefaultJsonProtocol.jsonFormat1(Test)

monkeygroover

import org.ensime.json.FamilyFormats
import spray.json._

object MainApp extends App {

  case class Foo(blah: String, blah2: Option[String])
  case class Bar(boo: List[Foo])

  val wat = Bar(Foo("dfsdf", Some("dsfd")) :: Foo("feefef", None) :: Nil)

monkeygroover

  case class ResultA()
  case class ResultB()
  case class ResultC()

  def test(): Future[Either[ResultA, ResultB]] = ???

  type Results = ResultA :+: ResultB :+: ResultC :+: CNil

  val foo = for {
    x <- test()

monkeygroover

case class PermutingCheckout(skuRules: Map[String, SKUPricer]) extends TotalCalculator {
  // as above but runs the rules in all permuted orders to find the best order to minimise the price
  val calculateTotal = (items: List[String]) => 
    items.foldMap(x => Map(x -> 1)) // create a map of SKU -> count of 'scanned' items
        .map { case (sku, skuCount) =>
        // get the rules for the SKU (if they exist) and map them to get the results for each SKU group
        skuRules.get(sku).map(rule => (rule.getPrice(skuCount)).success)
          .getOrElse(s"'$sku' rule not found".failureNel)
      }.reduce(_ |+| _) // sum the results for each SKU to get the final total
    }

monkeygroover

  val foo = (n: Int) => n.toString

  val bar = (s: String) => s.toInt

  // composing

  val f0 = bar compose foo
  println(f0(3))

  //what if the functions could fail..

monkeygroover

let fibSeq = Seq.unfold (fun s -> Some(fst s, (snd s, fst s + snd s))) (1I,1I)

let result = fibSeq 
             |> Seq.takeWhile(fun x -> x < pown 10I 999)
             |> Seq.length 
             |> (+) 1
             
printfn "%A" result

monkeygroover

type DivisorType = Deficient | Perfect | Abundant

let divisors number = {1 .. number/2} |> Seq.filter(fun n -> number % n = 0)

let sumDivisors = divisors >> Seq.sum

let divisorSumType number = match (number - sumDivisors number) with
                            | 0 -> Perfect
                            | d when d > 0 -> Deficient
                            | d -> Abundant

monkeygroover

open System.IO

let wordValue (word: string) = Seq.map(fun c -> (int c) - (int 'A') + 1) word 
                               |> Seq.sum

let result = File.ReadLines("p022_names.txt")
             |> Seq.collect(fun line -> line.Split ',') 
             |> Seq.map(fun quotedWord -> quotedWord.Trim [|'"'|] )
             |> Seq.sort
             |> Seq.mapi(fun i word -> (i + 1) * wordValue word)

monkeygroover

let factors number = seq {
    for divisor in 1 .. (float >> sqrt >> int) number do
    if number % divisor = 0 then
        yield divisor
        if number <> 1 then yield number / divisor //special case condition: when number=1 then divisor=(number/divisor), so don't repeat it
}

let d n = Seq.sum(factors n) - n
           
let all = {1..9999} |> Seq.map(fun a -> (a, d(a))) |> Map.ofSeq