The Basis is an exploration of pure declarative programming and reasoning in
Swift. It by no means contains idiomatic code, but is instead intended to be a
repository for structures and ideas grounded in theory and mathematics. Present
in this repository are the necessary components to handle system interaction,
control, data flow, and a number of extensions and improvements to the Swift
Standard Library and its structures. Higher-level APIs and structures are
generally excluded from the Basis to be implemented in other libraries.

It Gets Better!

Swift provides an excellent opportunity to not just witness, but actually
understand the formalization of many seemingly "complex" and abstract algebraic
structures without having to learn Haskell or ML or any of the other famous FP
languages. The documentation of types in this repository serves as a way to
deserialize a lot of the complex terms and jargon you may come across in these
languages. In this way, the Basis can be regarded as an encyclopedia of common
techniques and practices rather than a simple tutorial. As such, if the
documentation is too dense or unreadable, it means this library is failing one of
its unit tests! Clarification or rewrites of documentation to serve the broader
community are a priority and a promise.

Any questions or comments should be made into issues, or pull requests if you
feel you can word it better.

Let's make the world a bit less scary.

Getting Started

Basis comes wrapped up as a framework and iOS and OS X. Simply add the project
as a submodule, drag it to your project's file tree, and add it as a framework
dependency for your build. When all is said and done, just

import Basis


Because The Basis places emphasis on functions over structures, the majority of
the functions in this repository are free and combinatorial. Programming with
them then becomes a matter of selecting the proper combinators and compositional
operators to achieve a desired type signature.

To take a famous example from Haskell:

/// Sorts a list by recursively partitioning its elements into sublists around a
/// pivot element.
func quickSort<T : Comparable>(l : [T]) -> [T] {
    switch destruct(l) {
        case .Empty:
            return []
        case let .Cons(x, xs):
            let lesser  = xs.filter({ $0 < x })
            let greater = xs.filter({ $0 >= x })
            return quickSort(lesser) + [x] + quickSort(greater)

Or perhaps a more convoluted example:

/// Lift any 1-ary function to a function over Maybes.
func liftA<A, B>(f : A -> B) -> Maybe<A> -> Maybe<B> {
    return { a in Maybe.pure(f) <*> a }

/// Lift any 2-ary function to a function over 2 Maybes.   
func liftA2<A, B, C>(f : A -> B -> C) -> Maybe<A> -> Maybe<B> -> Maybe<C> {
    return { a in { b in Maybe.pure(f) <*> a <*> b } }

/// Lift any 3-ary function to a function over 3 Maybes.
func liftA3<A, B, C, D>(f : A -> B -> C -> D) -> Maybe<A> -> Maybe<B> -> Maybe<C> -> Maybe <D> {
    return { a in { b in { c in Maybe.pure(f) <*> a <*> b <*> c } } }

With such an architecture in place, we can replace the classic if-let pattern
for optionals with calls to liftA2:

let a = Maybe.just(6)
let b = Maybe<Int>.nothing()
let c = Maybe.just(5)

/// The result of adding 6 to Nothing is Nothing.
let nothing = liftA2(curry(+))(a)(b)

/// The result of adding 5 and 6 is 11
let something = liftA2(curry(+))(a)(c)

/// The result of packing 6, 5, and Nothing into a tuple is Nothing.
let noTupleHere = liftA3(pack3)(a)(b)(c)

We can also exploit the tools Swift has given us for laziness and use them to
build up infinite data structures despite having only a finite amount of memory.

/// Returns a stream of every Natural Number.  Because Streams are built up 
/// iteratively only on demand, we needn't load every element at once, 
/// just one at a time as they are requested. 
/// arr[0] == 0, arr[1] == 1, arr[2] == 2, ..., arr[n] == n
let naturalNumbers = iterate({ 1 + $0 })(0)

/// Returns a stream consisting of only the items in a given list.
/// arr[0] == "You", arr[1] == "Say", arr[2] == "Goodbye", arr[4] == "You", ...
let butISayHello = cycle(["You", "Say", "Goodbye"])

Or even use laziness to help with control flow.

/// A version of the factorial function that, while appearing recursive,
/// actually evaluates in a constant amount of stack space.  As such it will
/// never smash the stack no matter how large an input it is given. 
func noSmashFactorial(x : Double, _ acc : Double = 1.0) -> Trampoline<Double> {
    if x <= 1 {
        return now(acc)
    return later(noSmashFac(x - 1, acc * x))

/// The result of invoking this function is about 10^10^5.328.  Obviously, such
/// a number is completely unrepresentable in any bitwidth Swift gives us.  The 
/// thing to notice is that we would have pushed 50,000 frames onto the stack.  
/// Instead we push just 1. 
let inf = noSmashFactorial(50000).run()

We're no strangers to the Real World either. Swift is a profoundly imperative
language at heart, but that doesn't mean we can't do something about it. Enter
the IO Monad. Our IO Monad is the incarnation of an effect that has yet to

/// An effect that, when executed, will pause for input from the terminal, then
/// shout it back at you.
let eff = interact(pack • map({ $0.toUpper() }) • unpack)
/// ...
/// Executes the effect with the current state of the world.

System Requirements

The Basis supports OS X 10.9+ and iOS 7.0+


The Basis is released under the MIT license.

Further Reading