         return string
     }
     
+    public var fuzzyStringValue: String? {
+        if let s = strictStringValue {
+            return s
+        } else if let i = strictIntValue { // int first so if it's an int, we omit `1.0` in preference of `1`
+            return i.description
+        } else if let n = strictNumberValue {
+            return n.description
+        } else if let b = strictBoolValue {
+            return b.description
+        } else {
+            return nil
+        }
+    }
+}
+
+extension Node {
     public var arrayValue: [Node]? {
+        switch TypeEnforcingLevel {
+        case .strict:
+            return strictArrayValue
+        case .fuzzy:
+            return fuzzyArrayValue
+        }
+    }
+    
+    public var strictArrayValue: [Node]? {
         guard case let .ArrayValue(array) = self else { return nil }
         return array
     }
     
+    public var fuzzyArrayValue: [Node]? {
+        if let a = strictArrayValue {
+            return a
+        } else if let s = strictStringValue {
+            return s.characters
+                .split { $0 == "," }
+                .map(String.init)
+                .map { Node($0) }
+        } else {
+            return nil
+        }
+    }
+}
+
+extension Node {
     public var objectValue: [String : Node]? {
+        switch TypeEnforcingLevel {
+        case .strict:
+            return strictObjectValue
+        case .fuzzy:
+            return fuzzyObjectValue
+        }
+
+    }
+    
+    public var strictObjectValue: [String : Node]? {
         guard case let .ObjectValue(object) = self else { return nil }
         return object
+    }
+    
+    public var fuzzyObjectValue: [String : Node]? {
+        // I'm not sure if there's anything else that should map to an object.
+        // Possibly string w/ `&` or something,
+        // the issue is if there's no `&`, should it return empty dictionary?
+        return strictObjectValue
     }
 }
 

//  Copyright (c) 2014 Fuji Goro. All rights reserved.
//

public enum Node {
    case NullValue
    case BooleanValue(Bool)

    public var doubleValue: Double? {
        return numberValue
    }
}

extension Node {
    public var intValue: Int? {
        switch TypeEnforcingLevel {
        case .strict:
            return strictIntValue
        case .fuzzy:
            return fuzzyIntValue
        }
    }
    
    public var strictIntValue: Int? {
        guard let double = numberValue where double % 1 == 0 else {
            return nil
        }
