Merge pull request #199 from CodaFi/stringly-typed

Improve String Extension

Author: CodaFi

Cartfile.resolved

@@ -1,2 +1,2 @@
-github "typelift/SwiftCheck" "v0.2.2"
+github "typelift/SwiftCheck" "v0.2.3"
 github "typelift/Swiftx" "v0.2.1"

Carthage/Checkouts/SwiftCheck

@@ -6,6 +6,14 @@
 //  Copyright (c) 2014 Maxwell Swadling. All rights reserved.
 //
 
+/// An enum representing the possible values a string can match against.
+public enum StringMatcher {
+	/// The empty string.
+	case Nil
+	/// A cons cell.
+	case Cons(Character, String)
+}
+
 extension String {
 	/// Returns an array of strings at newlines.
 	public func lines() -> [String] {
@@ -22,4 +30,180 @@ extension String {
 	public static func lines() -> Iso<String, String, [String], [String]> {
 		return Iso(get: { $0.lines() }, inject: unlines)
 	}
+
+	/// Appends a character onto the front of a string.
+	public static func cons(head : Character, tail : String) -> String {
+		return String(head) + tail
+	}
+
+	/// Creates a string of n repeating characters.
+	public static func replicate(n : UInt, value : Character) -> String {
+		var l = ""
+		for _ in 0..<n {
+			l = String.cons(value, tail: l)
+		}
+		return l
+	}
+
+	/// Destructures a string.  If the string is empty the result is .Nil, otherwise the result is
+	/// .Cons(head, tail).
+	public func match() -> StringMatcher {
+		if count(self) == 0 {
+			return .Nil
+		} else if count(self) == 1 {
+			return .Cons(self[self.startIndex], "")
+		}
+		return .Cons(self[self.startIndex], self[advance(self.startIndex, 1)..<self.endIndex])
+	}
+
+	/// Returns a string containing the characters of the receiver in reverse order.
+	public func reverse() -> String {
+		return self.reduce(flip(String.cons), initial: "")
+	}
+
+	/// Maps a function over the characters of a string and returns a new string of those values.
+	public func map(f : Character -> Character) -> String {
+		switch self.match() {
+		case .Nil:
+			return ""
+		case let .Cons(hd, tl):
+			return String(f(hd)) + tl.map(f)
+		}
+	}
+
+	/// Removes characters from the receiver that do not satisfy a given predicate.
+	public func filter(p : Character -> Bool) -> String {
+		switch self.match() {
+		case .Nil:
+			return ""
+		case let .Cons(x, xs):
+			return p(x) ? (String(x) + xs.filter(p)) : xs.filter(p)
+		}
+	}
+
+	/// Applies a binary operator to reduce the characters of the receiver to a single value.
+	public func reduce<B>(f : B -> Character -> B, initial : B) -> B {
+		switch self.match() {
+		case .Nil:
+			return initial
+		case let .Cons(x, xs):
+			return xs.reduce(f, initial: f(initial)(x))
+		}
+	}
+
+	/// Applies a binary operator to reduce the characters of the receiver to a single value.
+	public func reduce<B>(f : (B, Character) -> B, initial : B) -> B {
+		switch self.match() {
+		case .Nil:
+			return initial
+		case let .Cons(x, xs):
+			return xs.reduce(f, initial: f(initial, x))
+		}
+	}
+
+	/// Takes two lists and returns true if the first string is a prefix of the second string.
+	public func isPrefixOf(r : String) -> Bool {
+		switch (self.match(), r.match()) {
+		case (.Cons(let x, let xs), .Cons(let y, let ys)) where (x == y):
+			return xs.isPrefixOf(ys)
+		case (.Nil, _):
+			return true
+		default:
+			return false
+		}
+	}
+
+	/// Takes two lists and returns true if the first string is a suffix of the second string.
+	public func isSuffixOf(r : String) -> Bool {
+		return self.reverse().isPrefixOf(r.reverse())
+	}
+
+	/// Takes two lists and returns true if the first string is contained entirely anywhere in the
+	/// second string.
+	public func isInfixOf(r : String) -> Bool {
+		func tails(l : String) -> [String] {
+			return l.reduce({ x, y in
+				return [String.cons(y, tail: head(x)!)] + x
+			}, initial: [""])
+		}
+
+		return any(tails(r), { self.isPrefixOf($0) })
+	}
+
+	/// Takes two strings and drops items in the first from the second.  If the first string is not a
+	/// prefix of the second string this function returns Nothing.
+	public func stripPrefix(r : String) -> Optional<String> {
+		switch (self.match(), r.match()) {
+		case (.Nil, _):
+			return .Some(r)
+		case (.Cons(let x, let xs), .Cons(let y, let ys)) where x == y:
+			return xs.stripPrefix(xs)
+		default:
+			return .None
+		}
+	}
+
+	/// Takes two strings and drops items in the first from the end of the second.  If the first 
+	/// string is not a suffix of the second string this function returns nothing.
+	public func stripSuffix(r : String) -> Optional<String> {
+		return self.reverse().stripPrefix(r.reverse()).map({ $0.reverse() })
+	}
+}
+
+extension String : Monoid {
+	typealias M = String
+
+	public static var mzero : String {
+		return ""
+	}
+
+	public func op(other : String) -> String {
+		return self + other
+	}
+}
+
+public func <>(l : String, r : String) -> String {
+	return l + r
+}
+
+extension String : Functor {
+	typealias A = Character
+	typealias B = Character
+	typealias FB = String
+
+	public func fmap(f : Character -> Character) -> String {
+		return self.map(f)
+	}
+}
+
+public func <^> (f : Character -> Character, l : String) -> String {
+	return l.fmap(f)
+}
+
+extension String : Pointed {
+	public static func pure(x : Character) -> String {
+		return String(x)
+	}
+}
+
+extension String : Applicative {
+	typealias FAB = [Character -> Character]
+
+	public func ap(a : [Character -> Character]) -> String {
+		return a.map({ return self.map($0) }).reduce("", combine: +)
+	}
+}
+
+public func <*> (f : Array<(Character -> Character)>, l : String) -> String {
+	return l.ap(f)
+}
+
+extension String : Monad {
+	public func bind(f : Character -> String) -> String {
+		return Array(self).map(f).reduce("", combine: +)
+	}
+}
+
+public func >>- (l : String, f : Character -> String) -> String {
+	return l.bind(f)
 }

Swiftz/StringExt.swift

@@ -26,7 +26,7 @@ struct EitherOf<A : Arbitrary, B : Arbitrary> : Arbitrary {
 	}
 
 	static func arbitrary() -> Gen<EitherOf<A, B>> {
-		return oneOf([ liftM(Either.left)(m1: A.arbitrary()), liftM(Either.right)(m1: B.arbitrary()) ]).fmap(EitherOf.create)
+		return Gen.oneOf([ liftM(Either.left)(m1: A.arbitrary()), liftM(Either.right)(m1: B.arbitrary()) ]).fmap(EitherOf.create)
 	}
 
 	static func shrink(bl : EitherOf<A, B>) -> [EitherOf<A, B>] {

SwiftzTests/EitherSpec.swift

@@ -27,8 +27,8 @@ struct ListOf<A : Arbitrary> : Arbitrary, Printable {
 	}
 
 	static func arbitrary() -> Gen<ListOf<A>> {
-		return sized { n in
-			return choose((0, n)).bind { k in
+		return Gen.sized { n in
+			return Gen<Int>.choose((0, n)).bind { k in
 				if k == 0 {
 					return Gen.pure(ListOf([]))
 				}
@@ -39,12 +39,7 @@ struct ListOf<A : Arbitrary> : Arbitrary, Printable {
 	}
 
 	static func shrink(bl : ListOf<A>) -> [ListOf<A>] {
-		switch bl.getList.match() {
-		case .Nil:
-			return []
-		case let .Cons(x, xs):
-			return [ ListOf<A>(xs) ] + ListOf<A>.shrink(ListOf<A>(xs)) + ListOf<A>.shrink(ListOf<A>(List(fromArray: A.shrink(x)) + xs))
-		}
+		return ArrayOf.shrink(ArrayOf([A](bl.getList))).map({ ListOf(List(fromArray: $0.getArray)) })
 	}
 }
 
@@ -136,10 +131,6 @@ class ListSpec : XCTestCase {
 			return xs.getList.map(+1) == xs.getList.fmap(+1)
 		}
 
-		property["map behaves"] = forAll { (xs : ListOf<Int>) in
-			return xs.getList.map(+1) == xs.getList.fmap(+1)
-		}
-
 		property["map behaves"] = forAll { (xs : ListOf<Int>) in
 			let fs = { List<Int>.replicate(2, value: $0) }
 			return (xs.getList >>- fs) == xs.getList.map(fs).reduce(+, initial: List())

SwiftzTests/ListSpec.swift

@@ -26,7 +26,10 @@ struct MaybeOf<A : Arbitrary> : Arbitrary, Printable {
 	}
 
 	static func arbitrary() -> Gen<MaybeOf<A>> {
-		return frequency([(1, Gen.pure(MaybeOf(Maybe<A>.none()))), (3, liftM({ MaybeOf(Maybe<A>.just($0)) })(m1: A.arbitrary()))])
+		return Gen.frequency([
+			(1, Gen.pure(MaybeOf(Maybe<A>.none()))),
+			(3, liftM({ MaybeOf(Maybe<A>.just($0)) })(m1: A.arbitrary()))
+		])
 	}
 
 	static func shrink(bl : MaybeOf<A>) -> [MaybeOf<A>] {

SwiftzTests/MaybeSpec.swift

@@ -17,5 +17,105 @@ class StringExtSpec : XCTestCase {
 			let u = String.unlines(l)
 			return u == (x + "\n")
 		}
+
+		property["Strings of Equatable elements obey reflexivity"] = forAll { (l : String) in
+			return l == l
+		}
+
+		property["Strings of Equatable elements obey symmetry"] = forAll { (x : String, y : String) in
+			return (x == y) == (y == x)
+		}
+
+		property["Strings of Equatable elements obey transitivity"] = forAll { (x : String, y : String, z : String) in
+			if (x == y) && (y == z) {
+				return x == z
+			}
+			return Discard()
+		}
+
+		property["Strings of Equatable elements obey negation"] = forAll { (x : String, y : String) in
+			return (x != y) == !(x == y)
+		}
+
+		property["Strings of Comparable elements obey reflexivity"] = forAll { (l : String) in
+			return l == l
+		}
+
+		property["String obeys the Functor identity law"] = forAll { (x : String) in
+			return (x.fmap(identity)) == identity(x)
+		}
+
+		reportProperty["String obeys the Functor composition law"] = forAll { (f : ArrowOf<Character, Character>, g : ArrowOf<Character, Character>, x : String) in
+			return ((f.getArrow • g.getArrow) <^> x) == (x.fmap(f.getArrow).fmap(g.getArrow))
+		}
+
+		property["String obeys the Applicative identity law"] = forAll { (x : String) in
+			return (pure(identity) <*> x) == x
+		}
+
+		reportProperty["String obeys the first Applicative composition law"] = forAll { (fl : ArrayOf<ArrowOf<Character, Character>>, gl : ArrayOf<ArrowOf<Character, Character>>, x : String) in
+			let f = fl.getArray.map({ $0.getArrow })
+			let g = gl.getArray.map({ $0.getArrow })
+			return (curry(•) <^> f <*> g <*> x) == (f <*> (g <*> x))
+		}
+
+		reportProperty["String obeys the second Applicative composition law"] = forAll { (fl : ArrayOf<ArrowOf<Character, Character>>, gl : ArrayOf<ArrowOf<Character, Character>>, x : String) in
+			let f = fl.getArray.map({ $0.getArrow })
+			let g = gl.getArray.map({ $0.getArrow })
+			return (pure(curry(•)) <*> f <*> g <*> x) == (f <*> (g <*> x))
+		}
+
+		property["String obeys the Monoidal left identity law"] = forAll { (x : String) in
+			return (x + String.mzero) == x
+		}
+
+		property["String obeys the Monoidal right identity law"] = forAll { (x : String) in
+			return (String.mzero + x) == x
+		}
+
+		property["cons behaves"] = forAll { (c : Character, s : String) in
+			return String.cons(c, tail: s) == String(c) + s
+		}
+
+		property["replicate behaves"] = forAll { (n : UInt, x : Character) in
+			return String.replicate(n, value: x) == List.replicate(n, value: String(x)).reduce({ $0 + $1 }, initial: "")
+		}
+
+		property["map behaves"] = forAll { (xs : String) in
+			return xs.map(identity) == xs.fmap(identity)
+		}
+
+		property["map behaves"] = forAll { (xs : String) in
+			let fs : Character -> String = { String.replicate(2, value: $0) }
+			return (xs >>- fs) == Array(xs).map(fs).reduce("", combine: +)
+		}
+
+		reportProperty["filter behaves"] = forAll { (xs : String, pred : ArrowOf<Character, Bool>) in
+			return xs.filter(pred.getArrow).reduce({ $0.0 && pred.getArrow($0.1) }, initial: true)
+		}
+
+		property["isPrefixOf behaves"] = forAll { (s1 : String, s2 : String) in
+			if s1.isPrefixOf(s2) {
+				return s1.stripPrefix(s2) != nil
+			}
+
+			if s2.isPrefixOf(s1) {
+				return s2.stripPrefix(s1) != nil
+			}
+
+			return Discard()
+		}
+
+		property["isSuffixOf behaves"] = forAll { (s1 : String, s2 : String) in
+			if s1.isSuffixOf(s2) {
+				return s1.stripSuffix(s2) != nil
+			}
+
+			if s2.isSuffixOf(s1) {
+				return s2.stripSuffix(s1) != nil
+			}
+
+			return Discard()
+		}
 	}
 }