repositories {
        // other repositories
        maven { url  "http://dl.bintray.com/codehelixinc/slatekit" }
    }

    dependencies {
        // other dependencies ...

        compile 'com.slatekit:slatekit-result:1.0.0'
    }

       
    import slatekit.results.*

    // Create success explicitly
    val start: Outcome<Int> = Success(10)

    // Properties
    println("success:     " + start.success)         // true
    println("status.code: " + start.status.code) // Codes.SUCCESS.code
    println("status.code: " + start.status.msg)  // Codes.SUCCESS.msg

    // Safely operate on values with map/flatMap
    val addResult = start.map { it + 1 }
    val subResult = start.flatMap { Success(it - 1) }

    // Check values
    println("contains:  " + addResult.contains(11))
    println("exists  :  " + addResult.exists { it == 11 })

    // Get values
    println("getOrNull: " + addResult.getOrNull())
    println("getOrElse: " + addResult.getOrElse { 0 })

    // On conditions
    subResult.onSuccess { println("onSuccess: " + it) } // 9
    subResult.onFailure { println("onFailure: " + it) } // N/A

    // Pattern match on branches ( Success / Failure )
    when (addResult) {
        is Success -> println("value: ${addResult.value}") // 11
        is Failure -> println("error: ${addResult.error}") // N/A
    }

    // Pattern match on status: Passed / Failed statuses
    when(start) {
        is Success -> when(start.status) {
            is Passed.Succeeded  -> println("Succeeded: " + start.msg)
            is Passed.Pending    -> println("Pending  : " + start.msg)
        }
        is Failure -> when(start.status) {
            is Failed.Denied     -> println("Denied    : " + start.msg)
            is Failed.Invalid    -> println("Invalid   : " + start.msg)
            is Failed.Ignored    -> println("Ignored   : " + start.msg)
            is Failed.Errored    -> println("Errored   : " + start.msg)
            is Failed.Unexpected -> println("Unexpected: " + start.msg)
        }
    }
        

    
    import slatekit.results.*

    // Result base class
    sealed class Result<out T, out E> {
        // implementation
    }

    // Success branch ( type T to store value of successful operation )
    data class Success<out T>(val value: T, override val status: Passed = Codes.SUCCESS) 
        : Result<T, Nothing>() {
        // implementation
    }

    // Failure branch ( type E to store error of failed operation )
    data class Failure<out E>(val error: E, override val status: Failed = Codes.ERRORED) 
        : Result<Nothing, E>() {
        // implementation
    }
     

    package slatekit.results

    interface class Status {
        abstract val code: Int
        abstract val msg: String
    }

    sealed class Passed : Status {
        data class Succeeded (override val code: Int, override val msg: String) : Passed()
        data class Pending   (override val code: Int, override val msg: String) : Passed()
    }

    sealed class Failed : Status {
        data class Denied    (override val code: Int, override val msg: String) : Failed()
        data class Ignored   (override val code: Int, override val msg: String) : Failed()
        data class Invalid   (override val code: Int, override val msg: String) : Failed()
        data class Errored   (override val code: Int, override val msg: String) : Failed()
        data class Unexpected(override val code: Int, override val msg: String) : Failed()
    }

    import slatekit.results.* 
    
    // Aliases simplify Result from 2 type parameters down to 1.
    typealias Try<T>       = Result<T, Exception>
    typealias Notice<T>    = Result<T, String>
    typealias Outcome<T>   = Result<T, Err>
    typealias Validated<T> = Result<T, Err.ErrorList>
    
    // You can now pass around the types more simply
    val result:Try<Int> = Success( "1".toInt() )
    println(result)

    
    // Builder interface can build Result<T, E> from strings, exception, err
    interface Builder<out E> {
        fun <T> invalid(): Result<T, E> = Failure(errorFromStr(null, Codes.INVALID), Codes.INVALID)
        fun <T> invalid(msg: String): Result<T, E> = Failure(errorFromStr(msg, Codes.INVALID), Codes.INVALID)
        fun <T> invalid(ex: Exception, status: Failed.Invalid? = null): Result<T, E> = Failure(errorFromEx(ex, Codes.INVALID), status ?: Codes.INVALID)
        fun <T> invalid(err: Err, status:Failed.Invalid? = null): Result<T, E> = Failure(errorFromErr(err, Codes.INVALID), status ?: Codes.INVALID)

        // misc code

    }
    // Misc builders ( See links / code )
    interface TryBuilder : Builder<Exception> { /* .. */ }
    object Tries : TryBuilder { /* ... */ }

    interface NoticeBuilder : Builder<String> { /* .. */ }
    object Notice : NoticeBuilder { /* ... */ }

    interface OutcomeBuilder : Builder<Err> { /* .. */ }
    object Outcome : OutcomeBuilder { /* ... */ }

    import slatkeit.results.builders.*

    // Build results ( imagine this is some user registration flow )
    // Try<T> = Result<T, Exception>
    val tried1 = Tries.success( User() )
    val tried2 = Tries.denied<User>("Phone exists")
    val tried3 = Tries.invalid<User>("Email required")

    // Outcome<T> = Result<T, Err>
    val outcome1 = Outcomes.success( User() )
    val outcome2 = Outcomes.denied<User>("Phone exists")
    val outcome3 = Outcomes.invalid<User>("Email required" )

    // Notice<T> = Result<T, String>
    val notice1 = Notices.success( User() )
    val notice2 = Notices.denied<User>("Phone exists")
    val notice3 = Notices.invalid<User>("Email required" )

    
    import slatekit.results.Err
    import slatekit.results.ErrorList

    // Build Err from various sources using convenience methods
    // From simple string
    val err1 = Err.of("Invalid email")

    // From Exception
    val err2 = Err.ex(Exception("Invalid email"))

    // From field name / value
    val err3 = Err.on("email", "abc123@", "Invalid email")

    // From status code
    val err4 = Err.code(Codes.INVALID)

    // From list of error strings
    val err5 = Err.list(listOf(
            "username must be at least 8 chars",
            "username must have 1 UPPERCASE letter"),
            "Username is invalid")

    // From list of Err types
    val err6 = Err.ErrorList(listOf(
            Err.on("email", "abc123 is not a valid email", "Invalid email"),
            Err.on("phone", "123-456-789 is not a valid U.S. phone", "Invalid phone")
    ), "Please correct the errors")

    // Create the Failure branch from the errors
    val result:Result<UUID, Err> = Failure(err6)
     

    
    // Suppose this an API endpoint to register a user

    // Simulate registration through a service layer
    val result:Outcome<User> = service.registerUser(user)

    // Convert the result back to HTTP somehow
    // NOTE: This is a simple conversion, see docs below
    when (result.status) {
        is Status.Succeeded  -> Http.Code200
        is Status.Invalid    -> Http.Code400
        is Status.Denied     -> Http.Code401
        is Status.Errored    -> Http.Code400
        else                 -> Http.Code500
    } 

      
    import slatekit.results.*
    
    // Success: Straight-forward
    val result = Success(42)

    // Success referenced as base type Result<Int, Err>
    val result1a: Result<Int, Err> = Success(42)

    // Success created with status codes / messages
    val result1b = Success(42, status = Codes.SUCCESS)
    val result1c = Success(42, msg = "Successfully processed")
    val result1d = Success(42, msg = "Successfully processed", code = 200)

    // Failure
    val result1e = Failure(Err.of("Invalid email"))

    // Failure referenced as base type Result<Int, Err>
    val result1f: Result<Int, Err> = Failure(Err.of("Invalid email"))

    // Failure created with status codes / messages
    val result1g = Failure(Err.of("Invalid email"), Codes.INVALID)
    val result1h = Failure(Err.of("Invalid email"), msg = "Invalid inputs")
    val result1i = Failure(Err.of("Invalid email"), msg = "Invalid inputs", code = Codes.INVALID.code)
     

      
    import slatekit.results.*

    // Create
    val result:Result<Int, Err> = Success(42)

    // Get value or default to null
    val value1:Int? = result.getOrNull()

    // Get value or default with value provided
    val value2:Int = result.getOrElse { 0 }

    // Map over the value
    val op1 = result.map { it + 1 }

    // Flat Map over the value
    val op2 = result.flatMap { Success(it + 1 ) }

    // Fold to transform both the success / failure into something else ( e.g. string here )
    val value3:String = result.fold({ "Succeeded : $it" }, {err -> "Failed : ${err.msg}" })

    // Get value if success
    result.onSuccess { println("Number = $it") }

    // Get error if failure
    result.onFailure { println("Error is ${it.msg}") }

    // Pattern match
    when(result) {
        is Success -> println(result.value)  // 42
        is Failure -> println(result.error)  // Err
    }

     
    import slatekit.results.*

    val result:Result<Int,Err> = Success(42)
    
    // Check if the value matches the criteria
    result.exists { it == 42 } // true
    
    // Check if the value matches the one provided
    result.contains(2)        // false

    // Pattern match 1: "Top-Level" on Success/Failure (Binary true / false )
    when(result) {
        is Success -> println(result.value)  // 42
        is Failure -> println(result.error)  // Err
    }

    // Pattern match 2: "Mid-level" on Status ( 7 logical groups )
    // NOTE: The status property is available on both the Success/Failure branches
    when(result.status) {
        is Passed.Succeeded  -> println(result.msg) // Success!
        is Passed.Pending    -> println(result.msg) // Success, but in progress
        is Failed.Denied     -> println(result.msg) // Security related 
        is Failed.Invalid    -> println(result.msg) // Bad inputs / data
        is Failed.Ignored    -> println(result.msg) // Ignored for processing
        is Failed.Errored    -> println(result.msg) // Expected errors
        is Failed.Unexpected -> println(result.msg) // Unexpected errors
    }

    // Pattern match 3: "Low-Level" on numeric code
    when(result.status.code) {
        Codes.SUCCESS.code    -> println("OK")
        Codes.QUEUED.code     -> println("Pending")
        Codes.UPDATED.code    -> println("User updated")
        Codes.DENIED.code     -> println("Log in again")
        Codes.DEPRECATED.code -> println("No longer supported")
        Codes.CONFLICT.code   -> println("Email already exists")
        else                  -> println("Other!!")
    }
     

    import slatekit.results.* 
    import slatekit.results.builders.Outcomes

    // Outcome<Int> = Result<Int, Err>
    val res1 = Outcomes.success(1, "Created User with id 1")
    val res2 = Outcomes.denied<Int>("Not authorized to send alerts")
    val res3 = Outcomes.ignored<Int>("Not a beta tester")
    val res4 = Outcomes.invalid<Int>("Email is invalid")
    val res5 = Outcomes.conflict<Int>("Duplicate email found")
    val res6 = Outcomes.errored<Int>("Phone is invalid")
    val res7 = Outcomes.unexpected<Int>("Unable to send confirmation code")
    

     
    import slatekit.results.* 
    import slatekit.results.builders.Tries

    // Try<Long> = Result<Long, Exception>
    val converted1:Try<Long> = Tries.of { "1".toLong() }

    // DeniedException will checked and converted to Status.Denied
    val converted2:Try<Long> = Tries.of<Long> {
        throw DeniedException("Token invalid")
    }

     
    import slatekit.results.* 
    import slatekit.results.builders.Tries
    import slatekit.common.validations.Validations

    // Model to validate
    val user = User(0, "batman_gotham", "batman", "", true, 34)
    
    // Validated<User> = Result<User, Err.ErrorList>
    val validated = Validations.collect<User,String, Err>(user) {
        listOf(
                isNotEmpty(user.firstName),
                isNotEmpty(user.lastName),
                isEmail(user.email)
        )
    }

    // Print first error
    when(validated) {
        is Success -> println("User model is valid") 
        is Failure -> println("User model failed with : " + validated.error.errors.first().msg)
    }

     
    // Simulate a denied exception ( Security related )
    val denied:Outcome<Long> = Outcomes.denied("Access token has expired")
    
    // Convert it to HTTP
    // This returns back the HTTP code + original Status
    val code:Pair<Int, Status> = Codes.toHttp(denied.status)
    println(code.first) // 401