erikkaplun

package prob

import scalaz._
import Scalaz._

import org.scalacheck.{ Arbitrary, Gen }

/** Types for working with probabilities, i.e. values of type `Double` in range `[0.0, 1.0]`. */
object `package` {

erikkaplun

global
	log 127.0.0.1	local0
#	log 127.0.0.1	local1 notice
	#log loghost	local0 info
	#maxconn 4096
	chroot /usr/share/haproxy
	user haproxy
	group haproxy
	daemon
	#debug

erikkaplun

import scala.io.Source
import scala.xml.XML

val ServiceUrl = "http://services.postcodeanywhere.co.uk/PostcodeAnywhereInternational/interactive/RetrieveByPostalCode/v2.20/xmla.ws"

val params = Map(
  "key" -> "UP26-TZ93-TK96-PJ69",
  "country" -> "United Kingdom".toUpperCase,
  "postalcode" -> "11312".replaceAll(" ", ""))

erikkaplun

// have

    val params = (
      (postalCode |> notNone("postal code missing")) |@|
      (countryCode |> notNone("country code missing")).flatMap(validIso2CountryCode("country code invalid"))
    )

// would like

    val params = (

erikkaplun

import shapeless._
import poly._
import syntax.std.tuple._

type Va[+A] = Validation[String, A]
type Vali[+A, -B] = Kleisli[Va, A, B]
def Vali[A, B](fn: A => Va[B]): Vali[A, B] = Kleisli[Va, A, B](fn)

implicit val vaBinding = new Bind[Va] {
  def map[A, B](fa: Va[A])(f: A => B): Va[B] = fa.map(f)

erikkaplun

[error]  found   : scalaz.syntax.ApplicativeBuilder[[X]scalaz.Validation[scalaz.NonEmptyList[String],X],String,String]
[error]  required: scalaz.ValidationNel[String,String]
[error]     (which expands to)  scalaz.Validation[scalaz.NonEmptyList[String],String]
[error]     params.map(_.toValidationNel).reduce(_ |@| _) { (code, countryCode3) =>
[error]                                            ^

erikkaplun

// libraryDependencies ++= Seq(
//  "org.scalaz" %% "scalaz-core" % "7.1.0",
//  "com.chuusai" %% "shapeless" % "2.0.0",
//  "org.typelevel" %% "shapeless-scalacheck" % "0.3",
//  "org.typelevel" %% "shapeless-spire" % "0.3",
//  "org.typelevel" %% "shapeless-scalaz" % "0.3"
// )


import shapeless._, contrib.scalaz._, syntax.std.tuple._

erikkaplun

    type Va[A] = Validation[String, A]
    type VaNel[A] = ValidationNel[String, A]

    import shapeless._, contrib.scalaz._, syntax.std.tuple._
    import syntax.std.function._, ops.function._
    import shapeless.ops.hlist._

    // for Kleisli and its >=>
    implicit val vaBinding = new Bind[Va] {
      def map[A, B](fa: Va[A])(f: A => B): Va[B] = fa.map(f)

erikkaplun

/**
  * Copyright (c) 2014 Erik Allik
  * 
  * All rights reserved.
  * 
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
  * 
  * 1. Redistributions of source code must retain the above copyright notice, this
  * list of conditions and the following disclaimer. 

erikkaplun

import scala.language.higherKinds

def optKleisli[M[_]: Applicative, A, B](fn: Kleisli[M, A, B]) = Kleisli[M, Option[A], Option[B]] {
  case Some(t) => fn(t).map(_.some)
  case None => Applicative[M].point(none[B])
}