# ExSwift

Set of Swift extensions for standard types and classes.

# Installation

Because of Xcode errors it's not possible to integrate this project with Cocoapods or as Embedded Framework. Read more at Dev Forum

## Use submodule and copy source code

- Add ExSwift as a submodule
- Open the
`ExSwift`

project folder, and drag`ExSwift`

sub folder with source code into the file navigator of your Xcode project. Make sure you select add to target - Use it

`components.takeFirst() { $0.completed }`

## Contents

# Extensions

## Array

Examples in the Wiki

#### Instance Methods

Name | Signature |
---|---|

`first` |
`first () -> Element?` |

`last` |
`last () -> Element?` |

`get` |
`get (index: Int) -> Element?` |

`remove` |
`remove <U: Equatable> (element: U)` |

`at` |
`at (indexes: Int...) -> Array` |

`take` |
`take (n: Int) -> Array` |

`takeWhile` |
`takeWhile (condition: (Element) -> Bool) -> Array` |

`takeFirst` |
`takeFirst (condition: (Element) -> Bool) -> Element?` |

`tail` |
`tail (n: Int) -> Array` |

`skip` |
`skip (n: Int) -> Array` |

`skipWhile` |
`skipWhile (condition: (Element) -> Bool) -> Array` |

`contains` |
`contains <T: Equatable> (item: T...) -> Bool` |

`difference` |
`difference <T: Equatable> (values: [T]...) -> [T]` |

`intersection` |
`intersection <U: Equatable> (values: [U]...) -> Array` |

`union` |
`union <U: Equatable> (values: [U]...) -> Array` |

`unique` |
`unique <T: Equatable> () -> [T]` |

`indexOf` |
`indexOf <T: Equatable> (item: T) -> Int?` |

`indexOf` |
`indexOf (condition: Element -> Bool) -> Int?` |

`lastIndexOf` |
`lastIndexOf <T: Equatable> (item: T) -> Int?` |

`zip` |
`zip (arrays: Array<Any>...) -> [[Any?]]` |

`partition` |
`partition (var n: Int, var step: Int? = nil) -> [Array]` `partition (var n: Int, var step: Int? = nil, pad: Element[]?) -> [Array]` |

`partitionAll` |
`partitionAll (var n: Int, var step: Int? = nil) -> [Array]` |

`partitionBy` |
`partitionBy <T: Equatable> (cond: (Element) -> T) -> [Array]` |

`shuffle` |
`shuffle ()` |

`shuffled` |
`shuffled () -> Array` |

`sample` (random) |
`sample (size n: Int = 1) -> [T]` |

`max` |
`max <T: Comparable> () -> T` |

`min` |
`min <T: Comparable> () -> T` |

`each` |
`each (call: (Element) -> ())` `each (call: (Int, Element) -> ())` |

`eachRight` |
`eachRight (call: (Element) -> ())` `eachRight (call: (Int, Element) -> ())` |

`any` |
`any (call: (Element) -> Bool) -> Bool` |

`all` |
`all (call: (Element) -> Bool) -> Bool` |

`reject` |
`reject (exclude: (Element -> Bool)) -> Array` |

`pop` |
`pop() -> Element` |

`push` |
`push(newElement: Element)` |

`shift` |
`shift() -> Element` |

`unshift` |
`unshift(newElement: Element)` |

`insert` |
`insert (newArray: Array, atIndex: Int)` |

`groupBy` |
`groupBy <U> (groupingFunction group: (Element) -> (U)) -> [U: Array]` |

`countBy` |
`countBy <U> (groupingFunction group: (Element) -> (U)) -> [U: Int]` |

`countWhere` |
`countWhere (test: (Element) -> Bool) -> Int` |

`reduce` |
`reduce (combine: (Element, Element) -> Element) -> Element?` |

`reduceRight` |
`reduceRight <U>(initial: U, combine: (U, Element) -> U) -> U` |

`mapFilter` |
`mapFilter <V> (mapFunction map: (Element) -> (V)?) -> [V]` |

`implode` |
`implode <C: ExtensibleCollection> (separator: C) -> C?` |

`flatten` |
`flatten <OutType> () -> [OutType]` |

`flattenAny` |
`flattenAny () -> [AnyObject]` |

`toDictionary` |
`toDictionary <U> (keySelector:(Element) -> U) -> [U: Element]` |

`toDictionary` |
`toDictionary <K, V> (transform: (Element) -> (key: K, value: V)?) -> [K: V]` |

`cycle` |
`cycle (n: Int? = nil, block: (T) -> ())` |

`bSearch` |
`bSearch (block: (T) -> (Bool)) -> T?` |

`bSearch` |
`bSearch (block: (T) -> (Int)) -> T?` |

`sortUsing` |
`sortUsing<U:Comparable>(block: ((T) -> U)) -> [T]` |

`transposition` |
`transposition (array: [[T]]) -> [[T]]` |

`permutation` |
`permutation (length: Int) -> [[T]]` |

`repeatedPermutation` |
`repeatedPermutation(length: Int) -> [[T]]` |

`combination` |
`combination (length: Int) -> [[Element]]` |

`repeatedCombination ` |
`repeatedCombination (length: Int) -> [[Element]]` |

#### Class Methods

Name | Signatures |
---|---|

`range` |
`range <U: ForwardIndex> (range: Range<U>) -> Array<U>` |

#### Operators

Name | Signature | Function |
---|---|---|

`-` |
`- <T: Equatable> (first: Array<T>, second: Array<T>) -> Array<T>` |
Difference |

`-` |
`- <T: Equatable> (first: Array<T>, second: T) -> Array<T>` |
Element removal |

`&` |
`& <T: Equatable> (first: Array<T>, second: Array<T>) -> Array<T>` |
Intersection |

`|` |
`| <T: Equatable> (first: Array, second: Array) -> Array` |
Union |

`* Int` |
`* <ItemType> (array: ItemType[], n: Int) -> [ItemType]` |
Returns a new array built by concatenating int copies of self |

`* String` |
`* (array: String[], separator: String) -> String` |
Equivalent to `array.implode(String)` |

`[rangeAsArray: x..y]` `[rangeAsArray: x...y]` |
`subscript(#rangeAsArray: Range<Int>) -> Array` |
Returns the sub-array from index x to index y |

`[x, y, ...]` |
`subscript(first: Int, second: Int, rest: Int...) -> Array` |
Returns the items at x, y |

## Int

Examples in the Wiki

#### Properties

Name |
---|

`NSTimeInterval` `years` |

`NSTimeInterval` `year` |

`NSTimeInterval` `days` |

`NSTimeInterval` `day` |

`NSTimeInterval` `hours` |

`NSTimeInterval` `hour` |

`NSTimeInterval` `minutes` |

`NSTimeInterval` `minute` |

`NSTimeInterval` `seconds` |

`NSTimeInterval` `second` |

#### Instance Methods

Name | Signatures |
---|---|

`times` |
`times <T> (call: (Int) -> T)` `times <T> (call: () -> T)` `times (call: () -> ())` |

`isEven` |
`isEven () -> Bool` |

`isOdd` |
`idOdd () -> Bool` |

`upTo` |
`upTo (limit: Int, call: (Int) -> ())` |

`downTo` |
`downTo (limit: Int, call: (Int) -> ())` |

`clamp` |
`clamp (range: Range<Int>) -> Int` `clamp (min: Int, max: Int) -> Int` |

`isIn` |
`isIn (range: Range<Int>, strict: Bool = false) -> Bool` |

`digits` |
`digits () -> Array<Int>` |

`abs` |
`abs () -> Int` |

`gcd` |
`gcd (n: Int) -> Int` |

`lcm` |
`lcm (n: Int) -> Int` |

#### Class Methods

Name | Signatures |
---|---|

`random` |
`random(min: Int = 0, max: Int) -> Int` |

## Float

Examples in the Wiki

#### Instance Methods

Name | Signature |
---|---|

`abs` |
`abs () -> Float` |

`sqrt` |
`sqrt () -> Float` |

`round` |
`round () -> Float` |

`ceil` |
`ceil () -> Float` |

`floor` |
`floor () -> Float` |

`clamp` |
`clamp (min: Float, _ max: Float) -> Float` |

#### Class Methods

Name | Signatures |
---|---|

`random` |
`random(min: Float = 0, max: Float) -> Float` |

## String

Examples in the Wiki

#### Properties

Name |
---|

`length` |

`capitalized` |

#### Instance Methods

Name | Signature |
---|---|

`explode` |
`explode (separator: Character) -> [String]` |

`at` |
`at (indexes: Int...) -> [String]` |

`matches` |
`matches (pattern: String, ignoreCase: Bool = false) -> [NSTextCheckingResult]?` |

`insert` |
`insert (index: Int, _ string: String) -> String` |

`ltrimmed` |
`ltrimmed () -> String` |

`ltrimmed` |
`ltrimmed (set: NSCharacterSet) -> String` |

`rtrimmed` |
`rtrimmed () -> String` |

`rtrimmed` |
`rtrimmed (set: NSCharacterSet) -> String` |

`trimmed` |
`trimmed () -> String` |

`rtrimmed` |
`rtrimmed (set: NSCharacterSet) -> String` |

`toDouble` |
`toDouble() -> Double?` |

`toFloat` |
`toFloat() -> Float?` |

`toUInt` |
`toUInt() -> UInt?` |

`toBool` |
`toBool() -> Bool?` |

`toDate` |
`toDate(format : String? = "yyyy-MM-dd") -> NSDate?` |

`toDateTime` |
`toDateTime(format : String? = "yyyy-MM-dd hh-mm-ss") -> NSDate?` |

#### Class Methods

Name | Signature |
---|---|

`random` |
`func random (var length len: Int = 0, charset: String = "...") -> String` |

#### Operators

Name | Signature |
---|---|

`[x]` |
`subscript(index: Int) -> String?` |

`[x..y]` `[x...y]` |
`subscript(range: Range<Int>) -> String` |

`[x, y, z]` |
`subscript (indexes: Int...) -> [String]` |

`S * n` |
`* (first: String, second: Int) -> String` |

`=~` |
`=~ (string: String, pattern: String) -> Bool` `=~ (string: String, options: (pattern: String, ignoreCase: Bool)) -> Bool` `=~ (strings: [String], pattern: String) -> Bool` `=~ (strings: [String], options: (pattern: String, ignoreCase: Bool)) -> Bool` |

`|~` |
`|~ (string: String, pattern: String) -> Bool` `|~ (string: String, options: (pattern: String, ignoreCase: Bool)) -> Bool` |

## Range

Examples in the Wiki

#### Instance Methods

Name | Signatures |
---|---|

`times` |
`times (call: (T) -> ())` `times (call: () -> ())` |

`each` |
`each (call: (T) -> ())` |

`toArray` |
`toArray () -> [T]` |

#### Class Methods

Name | Signature |
---|---|

`random` |
`random (from: Int, to: Int) -> Range<Int>` |

#### Operators

Name | Signature | Function |
---|---|---|

`=` |
`== <U: ForwardIndex> (first: Range<U>, second: Range<U>) -> Bool` |
Compares 2 ranges |

## Dictionary

Examples in the Wiki

#### Instance Methods

Name | Signatures |
---|---|

`difference` |
`difference <V: Equatable> (dictionaries: [Key: V]...) -> [Key: V]` |

`union` |
`union (dictionaries: [Key: Value]...) -> [Key: Value]` |

`intersection` |
`intersection <K, V where K: Equatable, V: Equatable> (dictionaries: [K: V]...) -> [K: V]` |

`has` |
`has (key: Key) -> Bool` |

`map` |
`map <K, V> (mapFunction map: (Key, Value) -> (K, V)) -> [K: V]` |

`mapFilter` |
`mapFilter <K, V> (mapFunction map: (Key, Value) -> (K, V)?) -> [K: V]` |

`mapValues` |
`mapValues <V> (mapFunction map: (Key, Value) -> (V)) -> [Key: V]` |

`mapFilterValues` |
`mapFilterValues <V> (mapFunction map: (Key, Value) -> V?) -> [Key: V]` |

`each` |
`each(eachFunction each: (Key, Value) -> ())` |

`filter` |
`filter(testFunction test: (Key, Value) -> Bool) -> [Key: Value]` |

`merge` |
`merge (dictionaries: [Key: Value]...) -> [Key: Value]` |

`shift` |
`shift () -> (Key, Value)` |

`groupBy` |
`groupBy <T> (groupingFunction group: (Key, Value) -> (T)) -> [T: Array<Value>]` |

`countBy` |
`countBy <T> (groupingFunction group: (Key, Value) -> (T)) -> [T: Int]` |

`countWhere` |
`countWhere (test: (Key, Value) -> (Bool)) -> Int` |

`any` |
`any (test: (Key, Value) -> (Bool)) -> Bool` |

`all` |
`all (test: (Key, Value) -> (Bool)) -> Bool` |

`reduce` |
`reduce <U> (initial: U, combine: (U, Element) -> U) -> U` |

`pick` , `at` |
`pick (keys: [Key]) -> Dictionary` `pick (keys: Key...) -> Dictionary` `at (keys: Key...) -> Dictionary` |

`toArray` |
`toArray <V> (mapFunction map: (Key, Value) -> V) -> [V]` |

#### Operators

Name | Signature | Function |
---|---|---|

`-` |
`- <K, V: Equatable> (first: Dictionary<K, V>, second: Dictionary<K, V>) -> Dictionary<K, V>` |
Difference |

`&` |
`& <K, V: Equatable> (first: Dictionary<K, V>, second: Dictionary<K, V>) -> Dictionary<K, V>` |
Intersection |

`|` |
`| <K, V: Equatable> (first: Dictionary<K, V>, second: Dictionary<K, V>) -> Dictionary<K, V>` |
Union |

## NSArray

Examples in the Wiki

#### Instance Methods

Name | Signatures |
---|---|

`cast` |
`cast <OutType> () -> [OutType]` |

`flatten` |
`flatten <OutType> () -> [OutType]` |

`flattenAny` |
`flattenAny () -> [AnyObject]` |

## SequenceOf

The following operations can be performed on sequences and are evaluated lazily. Each operation only takes the data it requires from the source sequence in order to return its result.

The `Sequence`

protocol cannot be extended, hence the following are extensions to `SequenceOf`

. They can be used as follows:

```
var source: Sequence = ...
var filteredSequence = SequenceOf(source).filter { ... }
```

#### Instance Methods

Name | Signatures |
---|---|

`first` |
`first () -> T?` |

`any` |
`any (call: (T) -> Bool) -> Bool` |

`get` |
`get (index: Int) -> T?` |

`get` |
`get (range: Range<Int>) -> SequenceOf<T>` |

`indexOf` |
`indexOf <U: Equatable> (item: U) -> Int?` |

`filter` |
`filter(include: (T) -> Bool) -> SequenceOf<T>` |

`reject` |
`reject (exclude: (T -> Bool)) -> SequenceOf<T>` |

`skipWhile` |
`skipWhile(condition:(T) -> Bool) -> SequenceOf<T>` |

`skip` |
`skip (n:Int) -> SequenceOf<T>` |

`contains` |
`contains<T:Equatable> (item: T) -> Bool` |

`take` |
`take (n:Int) -> SequenceOf<T>` |

`takeWhile` |
`takeWhile (condition:(T?) -> Bool) -> SequenceOf<T>` |

## Double

Examples in the Wiki

#### Instance Methods

Name | Signature |
---|---|

`abs` |
`abs () -> Double` |

`sqrt` |
`sqrt () -> Double` |

`round` |
`round () -> Double` |

`ceil` |
`ceil () -> Double` |

`floor` |
`floor () -> Double` |

`clamp` |
`clamp (min: Double, _ max: Double) -> Double` |

`roundToNearest` |
`roundToNearest(increment: Double) -> Double` |

#### Class Methods

Name | Signatures |
---|---|

`random` |
`random(min: Double = 0, max: Double) -> Double` |

# NSDate

#### Properties

Name | Signatures |
---|---|

`year` |
`Int` |

`month` |
`Int` |

`weekday` |
`Int` |

`weekMonth` |
`Int` |

`days` |
`Int` |

`hours` |
`Int` |

`minutes` |
`Int` |

`seconds` |
`Int` |

#### Instance Methods

Name | Signatures |
---|---|

`add` |
`add(seconds:Int=0, minutes:Int = 0, hours:Int = 0, days:Int = 0, weeks:Int = 0, months:Int = 0, years:Int = 0) -> NSDate` |

`addSeconds` |
`addSeconds (seconds:Int) -> NSDate ` |

`addMinutes` |
`addMinutes (minute:Int) -> NSDate ` |

`addHours` |
`addHours(hours:Int) -> NSDate ` |

`addDays` |
`addDays(days:Int) -> NSDate ` |

`addWeeks` |
`addWeeks(weeks:Int) -> NSDate` |

`addMonths` |
`addMonths(months:Int) -> NSDate` |

`addYears` |
`addYears(years:Int) -> NSDate ` |

`isAfter` |
`isAfter(date: NSDate) -> Bool` |

`isBefore` |
`isBefore(date: NSDate) -> Bool` |

`getComponent` |
`getComponent (component : NSCalendarUnit) -> Int` |

#### Operators

Name | Signatures |
---|---|

`==` |
`==(lhs: NSDate, rhs: NSDate) -> Bool` |

`<` |
`<(lhs: NSDate, rhs: NSDate) -> Bool` |

`>` |
`>(lhs: NSDate, rhs: NSDate) -> Bool` |

`<=` |
`<=(lhs: NSDate, rhs: NSDate) -> Bool` |

`>=` |
`>=(lhs: NSDate, rhs: NSDate) -> Bool` |

`==` |
`==(lhs: NSDate, rhs: NSDate) -> Bool` |

# Utilities

Examples in the Wiki

#### Class Methods

Name | Signatures |
---|---|

`after` |
`after <P, T> (n: Int, function: P -> T) -> (P -> T?)` `func after <T> (n: Int, function: () -> T) -> (() -> T?)` |

`once` |
`once <P, T> (function: P -> T) -> (P -> T?)` `once <T> (call: Void -> T) -> (Void -> T?)` |

`partial` |
`partial <P, T> (function: (P...) -> T, _ parameters: P...) -> ((P...) -> T?)` |

`bind` |
`bind <P, T> (function: (P...) -> T, _ parameters: P...) -> (() -> T)` |

`cached` |
`cached <P, R> (function: P -> R) -> (P -> R)` `cached <P, R> (function: (P...) -> R) -> ((P...) -> R)` `cached <P, R> (function: (P...) -> R, hash: ((P...) -> P)) -> ((P...) -> R)` |

#### Operators

Name | Signatures |
---|---|

`<=>` |
`<=> <T: Comparable>(lhs: T, rhs: T) -> Int` |

# To Do

- Wiki
- Xcode project for both iOS & OS X
- Review code comments
- Example project
- Installation instructions
- Benchmark