         case typeMismatched // TODO: include the expected and actual types if possible
         // TODO: add a mismatching values?
 
-        init(passed: Bool) {
+        internal init(passed: Bool) {
             if passed {
                 self = .passed
             } else {

}

public struct Expression<T> {
    let expression: () -> T
    /* let location: */

    var actual: T { return expression() }

    public var to: Expression { return self }
}

public struct TestResult {
    let description: String
    let state: State

    public enum State {
        case passed

import Foundation

internal enum Either<Left, Right> {
    case left(Left)
    case right(Right)
}

internal typealias Step = Either<Context, Test>
internal typealias Group = [Step]
internal typealias ResultStep = Either<String, TestResult>
internal typealias ResultGroup = [ResultStep]

public struct Test {
    internal let description: String
