Added Swift code test; vastly improved perf (#2)

Author: bkase

Sources/Atoms.swift

@@ -53,6 +53,7 @@ extension Doc {
     static let space: Doc = .char(" ")
     static let dot: Doc = .char(".")
     static let comma: Doc = .char(",")
+    static let semi: Doc = .char(";")
     static let backslash: Doc = .char("\\")
     static let equals: Doc = .char("=")
 }

Sources/DocMonoid.swift

@@ -17,3 +17,4 @@ extension Doc: Additive {
 
     static var zero: Doc { return .empty }
 }
+

Sources/Enclosed.swift

@@ -0,0 +1,67 @@
+//
+//  Enclosed.swift
+//  DoctorPretty
+//
+//  Created by Brandon Kase on 5/21/17.
+//
+//
+
+import Foundation
+import Operadics
+
+extension BidirectionalCollection where Iterator.Element == Doc, IndexDistance == Int, SubSequence.Iterator.Element == Doc {
+    
+    /// Intersperses punctuation inside docs
+    func punctuate(with punctuation: Doc) -> [Doc] {
+        if let d = first {
+            return [d] + self.dropFirst().reduce([]) { acc, d2 in
+                acc <> [punctuation, d2]
+            }
+        } else {
+            return []
+        }
+    }
+    
+    /// Enclose left right around docs interspersed with separator
+    /// Tries horizontal, then tries vertical
+    /// Indenting each element in the list by the indent level
+    /// Ex:
+    ///   enclose(left: [, right: ], separator: comma, indent: 4)
+    ///     let x = [foo, bar, baz]
+    ///   or
+    ///     let x = [
+    ///         foo,
+    ///         bar,
+    ///         baz
+    ///     ]
+    /// Note: The Haskell version sticks the separator at the front
+    func enclose(left: Doc, right: Doc, separator: Doc, indent: IndentLevel) -> Doc {
+        if count == 0 {
+            return left <> right
+        }
+        
+        let seps = repeatElement(separator, count: count-1)
+        let last = self[self.index(before: self.endIndex)]
+        let punctuated = zip(self.dropLast(), seps).map(<>) <> [last]
+        return (
+            .nest(indent,
+                  left <&&> punctuated.sep()
+            ) <&&> right
+        ).grouped
+    }
+    
+    /// See @enclose
+    func list(indent: IndentLevel) -> Doc {
+        return enclose(left: Doc.lbracket, right: Doc.rbracket, separator: Doc.comma, indent: indent)
+    }
+    
+    /// See @enclose
+    func tupled(indent: IndentLevel) -> Doc {
+        return enclose(left: Doc.lparen, right: Doc.rparen, separator: Doc.comma, indent: indent)
+    }
+    
+    /// See @enclose
+    func semiBraces(indent: IndentLevel) -> Doc {
+        return enclose(left: Doc.lbrace, right: Doc.rbrace, separator: Doc.semi, indent: indent)
+    }
+}

Sources/HighLevelCombinators.swift

@@ -44,66 +44,66 @@ extension Doc {
         return Doc.linebreak.grouped
     }
 
-    /// Puts a line between x and y that can be flattened
+    /// Puts a line between x and y that can be flattened to a space
     static func <&>(x: Doc, y: Doc) -> Doc {
         return x <> .line <> y
     }
 
-    /// Puts a line between x and y undconditionally
+    /// Puts a line between x and y that can be flattened with no space
     static func <&&>(x: Doc, y: Doc) -> Doc {
         return x <> .linebreak <> y
     }
 }
 
-extension Doc {
+extension Sequence where Iterator.Element == Doc {
     /// Concat all horizontally if it fits, but if not
     /// all vertical
-    static func sep<S: Sequence>(_ docs: S) -> Doc where S.Iterator.Element == Doc {
-        return vsep(docs).grouped
+    func sep() -> Doc {
+        return vsep().grouped
     }
 
     /// Concats all horizontally until end of page
     /// then puts a line and repeats
-    static func fillSep<S: Sequence>(_ docs: S) -> Doc where S.Iterator.Element == Doc {
-        return fold(docs: docs, combine: <%>)
+    func fillSep() -> Doc {
+        return fold(combineDocs: <%>)
     }
 
     /// Concats all horizontally with spaces in between
-    static func hsep<S: Sequence>(_ docs: S) -> Doc where S.Iterator.Element == Doc {
-        return fold(docs: docs, combine: <+>)
+    func hsep() -> Doc {
+        return fold(combineDocs: <+>)
     }
 
     /// Concats all vertically, if a group undoes, concat with space
-    static func vsep<S: Sequence>(_ docs: S) -> Doc where S.Iterator.Element == Doc {
-        return fold(docs: docs, combine: <&>)
+    func vsep() -> Doc {
+        return fold(combineDocs: <&>)
     }
 
     /// Concats all horizontally no spaces if fits
     /// Otherwise all vertically
-    static func cat<S: Sequence>(_ docs: S) -> Doc where S.Iterator.Element == Doc {
-        return vcat(docs).grouped
+    func cat() -> Doc {
+        return vcat().grouped
     }
 
     /// Concats all horizontally until end of page
     /// then puts a linebreak and repeats
-    static func fillCat<S: Sequence>(_ docs: S) -> Doc where S.Iterator.Element == Doc {
-        return fold(docs: docs, combine: <%%>)
+    func fillCat() -> Doc {
+        return fold(combineDocs: <%%>)
     }
 
     /// Concats all horizontally with no spaces
-    static func hcat<S: Sequence>(_ docs: S) -> Doc where S.Iterator.Element == Doc {
-        return fold(docs: docs, combine: <>)
+    func hcat() -> Doc {
+        return fold(combineDocs: <>)
     }
 
     /// Concats all vertically, if a group undoes, concat with no space
-    static func vcat<S: Sequence>(_ docs: S) -> Doc where S.Iterator.Element == Doc {
-        return fold(docs: docs, combine: <&&>)
+    func vcat() -> Doc {
+        return fold(combineDocs: <&&>)
     }
 
-    static func fold<S: Sequence>(docs: S, combine: (Doc, Doc) -> Doc) -> Doc where S.Iterator.Element == Doc {
-        var iter = docs.makeIterator()
+    func fold(combineDocs: (Doc, Doc) -> Doc) -> Doc {
+        var iter = makeIterator()
         if let first = iter.next() {
-           return IteratorSequence(iter).reduce(first, combine)
+           return IteratorSequence(iter).reduce(first, combineDocs)
         } else {
             return Doc.zero
         }

Sources/RenderPretty.swift

@@ -8,15 +8,22 @@
 
 import Foundation
 
-typealias CompareStrategy = (IndentLevel, ColumnCount, Width, RibbonWidth) -> (SimpleDoc, SimpleDoc) -> SimpleDoc
+typealias CompareStrategy = (IndentLevel, ColumnCount, Width, RibbonWidth) -> (SimpleDoc, () -> SimpleDoc) -> SimpleDoc
+
+indirect enum List<T> {
+    case Nil
+    case Cons(T, List<T>)
+}
+
 // TODO: Tune this datastructure to increase render performance
 //       Good properties:
 //              fast prepend
 //              fast (head, rest) decomposition
 //              shared substructure
 //       The obvious choice is a linked list, but maybe a clever sequence
-//       could be better
-typealias Docs = [(Int, Doc)]
+//       could be better. Also, perhaps not using the enum-list will speed
+//       things up more.
+typealias Docs = List<(Int, Doc)>
 
 extension Doc {
     func renderPrettyDefault() -> SimpleDoc {
@@ -40,9 +47,10 @@ extension Doc {
             z: (IndentLevel, ColumnCount) -> SimpleDoc,
             indentationDocs: Docs
         ) -> SimpleDoc {
-            if let head = indentationDocs.first {
+            switch indentationDocs {
+            case .Nil: return z(currNesting, currColumn)
+            case let .Cons(head, rest):
                 let (indent, doc) = head
-                let rest = Array(indentationDocs.dropFirst())
 
                 switch doc {
                 case .empty:
@@ -56,41 +64,40 @@ extension Doc {
                 case ._line:
                     return SimpleDoc.line(indent: indent, best(currNesting: indent, currColumn: indent, z: z, indentationDocs: rest))
                 case let .flatAlt(primary, whenFlattened: _):
-                    return best(currNesting: currNesting, currColumn: currColumn, z: z, indentationDocs: [(indent, primary)] + rest)
+                    return best(currNesting: currNesting, currColumn: currColumn, z: z, indentationDocs: .Cons((indent, primary), rest))
                 case let .concat(d1, d2):
-                    return best(currNesting: currNesting, currColumn: currColumn, z: z, indentationDocs: [(indent, d1), (indent, d2)] + rest)
+                    return best(currNesting: currNesting, currColumn: currColumn, z: z, indentationDocs: .Cons((indent, d1), .Cons((indent, d2), rest)))
                 case let .nest(indent_, d):
                     let newIndent = indent + indent_
-                    return best(currNesting: currNesting, currColumn: currColumn, z: z, indentationDocs: [(newIndent, d)] + rest)
+                    return best(currNesting: currNesting, currColumn: currColumn, z: z, indentationDocs: .Cons((newIndent, d), rest))
                 case let .union(longerLines, shorterLines):
                     return compareStrategy(
                         currNesting,
                         currColumn,
                         pageWidth,
                         ribbonChars
                     )(
-                        best(currNesting: currNesting, currColumn: currColumn, z: z, indentationDocs: [(indent, longerLines)] + rest),
-                        best(currNesting: currNesting, currColumn: currColumn, z: z, indentationDocs: [(indent, shorterLines)] + rest)
+                        best(currNesting: currNesting, currColumn: currColumn, z: z, indentationDocs: .Cons((indent, longerLines), rest)),
+                        /// Laziness is needed here to prevent horrible performance!
+                        { () in best(currNesting: currNesting, currColumn: currColumn, z: z, indentationDocs: .Cons((indent, shorterLines), rest)) }
                     )
                 case let .column(f):
-                    return best(currNesting: currNesting, currColumn: currColumn, z: z, indentationDocs: [(indent, f(currColumn))] + rest)
+                    return best(currNesting: currNesting, currColumn: currColumn, z: z, indentationDocs: .Cons((indent, f(currColumn)), rest))
                 case let .nesting(f):
-                    return best(currNesting: currNesting, currColumn: currColumn, z: z, indentationDocs: [(indent, f(indent))] + rest)
+                    return best(currNesting: currNesting, currColumn: currColumn, z: z, indentationDocs: .Cons((indent, f(indent)), rest))
                 case let .columns(f):
-                    return best(currNesting: currNesting, currColumn: currColumn, z: z, indentationDocs: [(indent, f(.some(pageWidth)))] + rest)
+                    return best(currNesting: currNesting, currColumn: currColumn, z: z, indentationDocs: .Cons((indent, f(.some(pageWidth))), rest))
                 case let .ribbon(f):
-                    return best(currNesting: currNesting, currColumn: currColumn, z: z, indentationDocs: [(indent, f(.some(ribbonChars)))] + rest)
+                    return best(currNesting: currNesting, currColumn: currColumn, z: z, indentationDocs: .Cons((indent, f(.some(ribbonChars))), rest))
                 }
-            } else {
-                return z(currNesting, currColumn)
             }
         }
 
-        return best(currNesting: 0, currColumn: 0, z: { _, _ in SimpleDoc.empty }, indentationDocs: [(0, self)])
+        return best(currNesting: 0, currColumn: 0, z: { _, _ in SimpleDoc.empty }, indentationDocs: .Cons((0, self), .Nil))
     }
 
     /// Compares the first two lines of the documents
-    static func nicest1(nesting: IndentLevel, column: ColumnCount, pageWidth: Width, ribbonWidth: RibbonWidth) -> (SimpleDoc, SimpleDoc) -> SimpleDoc {
+    static func nicest1(nesting: IndentLevel, column: ColumnCount, pageWidth: Width, ribbonWidth: RibbonWidth) -> (SimpleDoc, () -> SimpleDoc) -> SimpleDoc {
         return { d1, d2 in
             let wid = min(pageWidth - column, ribbonWidth - column + nesting)
 
@@ -109,7 +116,7 @@ extension Doc {
             if fits(prefix: min(nesting, column), w: wid, doc: d1) {
                 return d1
             } else {
-                return d2
+                return d2()
             }
         }
     }

Tests/DoctorPrettyTests/DoctorPrettySpec.swift

@@ -30,7 +30,7 @@ extension Doc: Arbitrary {
 		        (3, stringDocGen),
 		        (1, lineOrEmptyGen)
 		    ]).proliferate(withSize: 10)
-              .map{ ds in Doc.cat(ds) }
+	          .map{ $0.cat() }
     }
 }