Skip to content
main
Switch branches/tags
Go to file
Code

Latest commit

Now one can import this library with SPM, and lock master / this commit hash and not rely on tags
0ec0a56

Git stats

Files

Permalink
Failed to load latest commit information.
Type
Name
Latest commit message
Commit time
 
 
 
 
 
 
 
 
 
 
 
 

swift-prelude

Swift 5.1 Build Status @pointfreeco

A collection of frameworks to enhance the Swift language.

Stability

This library should be considered alpha, and not stable. Breaking changes will happen often.

Installation

import PackageDescription

let package = Package(
  dependencies: [
    .package(url: "https://github.com/pointfreeco/swift-prelude.git", .branch("master")),
  ]
)

Table of Contents

Prelude

A collection of types and functions to build powerful abstractions and enhance the Swift standard library.

Either

A type to express a value that holds one of two other types.

import Either

let intOrString = Either<Int, String>.left(2)

intOrString
  .bimap({ $0 + 1 }, { $0 + "!" }) // => .left(3)

Optics

A Lens type and a bridge between the lens world and the Swift key path world.

import Optics
import Prelude

struct User {
  var id: Int
  var name: String
}

let uppercased: (String) -> String = { $0.uppercased() }

let user = User(id: 1, name: "Blob")

user
  |> \.id .~ 2
  |> \.name %~ uppercased

// => User(2, "BLOB")

ValidationSemigroup

The Validation<E, A> type is a type similar to Result<E, A>, except it is given a different applicative instance in the case that E is a semigroup. This allows you to accumulate multiple errors into E instead of just taking the first error:

import Prelude
import ValidationSemigroup

struct User { let name: String; let bio: String; let email: String }
let createUser = { name in { bio in { email in User(name: name, bio: bio, email: email) } } }

func validate(name: String) -> Validation<[String], String> {
  return !name.isEmpty
    ? pure(name)
    : .invalid(["Name must be at least 1 character."])
}

func validate(bio: String) -> Validation<[String], String> {
  return bio.count <= 10
    ? pure(bio)
    : .invalid(["Bio must 10 characters or less."])
}

func validate(email: String) -> Validation<[String], String> {
  return email.contains("@")
    ? pure(email)
    : .invalid(["Email must be valid."])
}

let validUser = pure(createUser)
  <*> validate(name: "Blob")
  <*> validate(bio: "I'm a blob")
  <*> validate(email: "blob@pointfree.co")
// => .valid(User(name: "Blob", bio: "I'm a blob", email: "blob@pointfree.co"))

let invalidUser = pure(createUser)
  <*> validate(name: "Blob")
  <*> validate(bio: "Blobbin around the world")
  <*> validate(email: "blob")
// => .invalid(["Bio must 10 characters or less.", "Email must be valid."])

For more information, watch Stephen Celis’ talk.

ValidationNearSemiring

This Validation<E, A> type is a type similar to Result<E, A> and the above Validation, except it is given a different applicative instance in the case that E is a NearSemiring. This allows you to accumulate errors that describe conditions that hold with both “and” and “or”, e.g. name is required and either email or phone is required.

License

All modules are released under the MIT license. See LICENSE for details.

About

🎶 A collection of types and functions that enhance the Swift language.

Topics

Resources

License

Packages

No packages published