Functional routers & parsers #5

ilyapuchka · 2017-11-02T00:30:09Z

No description provided.

ilyapuchka · 2017-11-02T10:17:09Z

DeeperFunc/Deeper.swift

+
+public typealias RouteComponents = (path: [String], query: [String: String])
+
+public protocol PatternState {}


Following phantom types represent pattern states:

pattern can have only path and no query, i.e. "users" /> :int

pattern can have path and query, i.e. "users" /> :int .? string("sort")

pattern can be "closed", meaning it does not expect any more pattern components (after any pattern used in the middle), i.e. any /> "users" or "users" /> any, or any simple pattern with just path or path and query

pattern can be "open", meaning it needs some subsequent pattern component to be closed, i.e. in "users" /> any /> "info" it's the state of the patter after any is applied

ilyapuchka · 2017-11-02T10:25:19Z

DeeperFunc/Deeper.swift

+
+    func map<S>(_ iso: PartialIso<A, Any>) -> RoutePattern<Any, S> {
+        return .init(parse: {
+            guard let result = self.parse($0) else { return nil }


not applying iso.apply here as then it will i.e. convert parsed int to string because it's the type of "type-erased" pattern wrapper used for parsing string format, and then router will not be able to cast in map. The only option is to use ExpressibleByStringLiteral or similar protocol to convert it back from string to type we need in router...

ilyapuchka · 2017-11-02T10:29:59Z

DeeperFunc/Deeper.swift

+            .replacingOccurrences(of: "Optional<", with: "")
+            .replacingOccurrences(of: ">", with: "")
+            .lowercased()
+    } else if typeString.contains("Either<") {


actually this will never be used unless custom parameter type is used, but it's not currently exposed as public API

ilyapuchka · 2017-11-02T10:30:04Z

DeeperFunc/Maybe.swift

+        return .init(parse: parseRight(lhs, rhs), print: printRight(lhs, rhs), template: templateAnd(lhs, rhs))
+    }
+
+    public static func /?<B>(lhs: RoutePattern, rhs: RoutePattern<B, S>) -> RoutePattern<(A, B?), S> {


maybe there should be /? and >/? so that it expresses that parameter from left part is carried on or not? but >/? feels like set of random symbols

ilyapuchka · 2017-11-02T10:54:03Z

DeeperFunc/PartialIso.swift

+    )
+}
+
+func unwraped<A, B>(_ iso: PartialIso<A, B?>) -> PartialIso<A, B> {


ilyapuchka · 2017-11-02T10:55:22Z

DeeperFunc/PartialIso.swift

+infix operator >>>
+infix operator <<<
+
+public struct PartialIso<A, B> {


Does this really improve readability comparing with just passing apply/unapply function pairs and making some type casting in them? Especially with usage of >>> and <<< operators

Decided to throw this type away as just using pair of closures is easier to read and I don't need it as a standalone type

ilyapuchka · 2017-11-02T11:19:08Z

DeeperFunc/Router.swift

+    }
+
+    @discardableResult
+    public func add4<A, B, C, D>(_ intent: @escaping (A, B, C, D) -> U, format: String) -> Router {


using add for all function variants results in ambiguity (why?), so had to add this 4 as a suffix

Solved by adding extra pair of brackets around method variant for single parameter

ilyapuchka · 2017-11-02T11:21:18Z

DeeperFunc/Deeper.swift

+
+public struct RoutePattern<A/*pattern type*/, S: PatternState> {
+    public let parse: Parser<A> // parses path components exctracting underlying type of pattern
+    public let print: Printer<A> // converts pattern with passed in value to template component


print is actually not that useful in context of deep links as we don't need to produce urls in code, so probably can be dropped. Though it can be used for application wide navigation, so that openURL is used always instead of passing manually created intents around.

ilyapuchka · 2017-11-02T11:46:05Z

DeeperFunc/Path.swift

+public let double: RoutePattern<Double, Path> = pathParam(.double)
+
+// drop left param
+infix operator /> : MultiplicationPrecedence


not fond of all these custom operators, but using / for all cases makes expressions too complex for swift compiler. In future can be probably solved with ExpressibleByStringLiteral conformance for Void type of generic parameter

ilyapuchka · 2017-11-05T00:41:19Z

DeeperFuncTests/Utils.swift

+    case optionalParam(Int?)
+    case optionalSecondParam(Int, String?)
+
+    func deconstruct<A>(_ constructor: ((A) -> Intent)) -> A? {


This method is used instead of PartialIso that would otherwise be created separately for each case, but will effectively do the same - match specific case with it's constructor and extract associated values.
It's boilerplate, but seems like less code to write comparing with PartialIso.

This code

if let values = value.deconstruct(Enum.somecase) {...}

is equivalent to this

if case let Enum.somecase(values) = value {...}

but can be mapped and used without if, when standard pattern matching can't be only used in if case/guard case statements.

ilyapuchka · 2017-11-05T00:43:30Z

DeeperFunc/Router.swift

+    }
+
+    private func add(_ route: RoutePattern<U, Path>) -> Router {
+        self.route = self.route.map({ oldValue in


self.route wraps all individual routes. When matching or printing using this route is equivalent to iterating through array of routes, but this will do it with recursion.

ilyapuchka · 2017-11-05T00:59:43Z

DeeperFunc/Router.swift

+
+    @discardableResult
+    public func add<A, S: ClosedPatternState>(_ intent: @escaping ((A)) -> U, route: RoutePattern<A, S>) -> Router {
+        return add(route.map({ intent($0) }, { $0.deconstruct(intent) }))


All routes are mapped to the same generic type, <U, Path>, so that they can be composed into one route.
Input parameter of second closure will be value of U, but router needs A, which is associated value of enum case (if enum is used of course). But we only have constructor of U, so we don't know with what case to match the value. This is done instead with deconstruct method that does pattern matching and returns associated values.
This is only needed to be able to print urls for specific values of U. We could print just using route itself (see this commit), but we can't easily get it back from router, so will need to store all routes in some constants. That might be a good solution, as it will not require boilerplate implementation of deconstruct, but it is not safe: route can be used to print without being added to router and then printed url will be not matched. With mapping and using deconstruct only routes that are added to router can be used to print urls, so it's guarantied that url will be matched.

ilyapuchka · 2017-11-05T01:05:50Z

DeeperFunc/Router.swift

+
+    @discardableResult
+    public func add<A, B, C, S: ClosedPatternState>(_ intent: @escaping ((A, B, C)) -> U, route: RoutePattern<((A, B), C), S>) -> Router {
+        return add(route.map({ intent(flatten($0)) }, { $0.deconstruct(intent).map(parenthesize) }))


Here we also need to regroup values using parenthesize from (A, B, C) to ((A, B), C) as this is what route expects

ilyapuchka · 2017-11-05T01:13:29Z

DeeperFunc/Router.swift

+extension Router {
+
+    public func url(for route: U) -> URL? {
+        return self.route?.print(route).flatMap(url(from:))


now we can just use composite route to print url and we do it with concrete value of U, not a route pattern.

ilyapuchka · 2017-11-05T01:15:07Z

DeeperFunc/String.swift

+    return .init(parse: parseRight(lhs, rhs), print: printRight(lhs, rhs), template: templateAnd(lhs, rhs))
+}
+
+extension String {


all these operators could be probably replaced with conditional conformance, then maybe / could be used without creating too complex expressions

ilyapuchka · 2017-11-05T01:16:45Z

DeeperFunc/StringParser.swift

+    return { components in
+        var components = components
+        var pathPatterns = [RoutePattern<Any, S>]()
+        while !components.isEmpty {


can we use the same approach as with routes, using composition and recursion instead of loop?

ilyapuchka · 2017-11-05T01:19:51Z

DeeperFunc/Router.swift

+
+    @discardableResult
+    public func add<S: ClosedPatternState>(_ intent: U, route: RoutePattern<Void, S>) -> Router {
+        return add(route.map({ intent }, { $0 == intent ? () : nil }))


for cases without parameters we can just use ==

ilyapuchka added 9 commits October 29, 2017 18:24

functional routes

02207c3

renamed concat operators

8f9830d

extracted deeplink handling types to shared sources

e70a67b

converting string to pattern

ac3189f

introduced PartialIso

55907ae

parsing maybe template format

640d6bc

fixed parsing and printing any pattern

743a3c3

some refactoring

0abb7bf

removed unneeded code

364a6f8

ilyapuchka commented Nov 2, 2017

View reviewed changes

ilyapuchka added 3 commits November 2, 2017 16:14

solved issue with type arasing and map in routers

4270b25

getting rid of PartialIso in favor of simpler closure pairs

5f0535e

router improvements

3e8fabf

ilyapuchka force-pushed the func branch from 3e8fabf to 9fded66 Compare November 4, 2017 19:47

ilyapuchka commented Nov 5, 2017

View reviewed changes

use single route instead of array and deconstruct to print

b90a58b

ilyapuchka commented Nov 5, 2017

View reviewed changes

ilyapuchka force-pushed the func branch from 9fded66 to b90a58b Compare November 5, 2017 00:59

ilyapuchka commented Nov 5, 2017

View reviewed changes

ilyapuchka added 3 commits November 7, 2017 20:15

some refactoring

2278a6b

added open(route:) method

281d3ac

readme update

5153fa6

ilyapuchka merged commit 19933ea into master Nov 12, 2017

ilyapuchka deleted the func branch November 12, 2017 14:39

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Functional routers & parsers #5

Functional routers & parsers #5

ilyapuchka commented Nov 2, 2017

ilyapuchka Nov 2, 2017

ilyapuchka Nov 2, 2017

ilyapuchka Nov 2, 2017

ilyapuchka Nov 2, 2017

ilyapuchka Nov 2, 2017 •

edited

Loading

ilyapuchka Nov 2, 2017 •

edited

Loading

ilyapuchka Nov 4, 2017

ilyapuchka Nov 2, 2017

ilyapuchka Nov 4, 2017

ilyapuchka Nov 2, 2017

ilyapuchka Nov 2, 2017 •

edited

Loading

ilyapuchka Nov 5, 2017

ilyapuchka Nov 5, 2017 •

edited

Loading

ilyapuchka Nov 5, 2017 •

edited

Loading

ilyapuchka Nov 5, 2017 •

edited

Loading

ilyapuchka Nov 5, 2017

ilyapuchka Nov 5, 2017

ilyapuchka Nov 5, 2017

ilyapuchka Nov 5, 2017


		public typealias RouteComponents = (path: [String], query: [String: String])

		public protocol PatternState {}

Functional routers & parsers #5

Functional routers & parsers #5

Conversation

ilyapuchka commented Nov 2, 2017

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

ilyapuchka Nov 2, 2017 • edited Loading

Choose a reason for hiding this comment

ilyapuchka Nov 2, 2017 • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

ilyapuchka Nov 2, 2017 • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

ilyapuchka Nov 5, 2017 • edited Loading

Choose a reason for hiding this comment

ilyapuchka Nov 5, 2017 • edited Loading

Choose a reason for hiding this comment

ilyapuchka Nov 5, 2017 • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

ilyapuchka Nov 2, 2017 •

edited

Loading

ilyapuchka Nov 2, 2017 •

edited

Loading

ilyapuchka Nov 2, 2017 •

edited

Loading

ilyapuchka Nov 5, 2017 •

edited

Loading

ilyapuchka Nov 5, 2017 •

edited

Loading

ilyapuchka Nov 5, 2017 •

edited

Loading