Code Quality Rank: L4
Programming language: Swift
License: MIT License
Tags: Reflection    
Latest version: v0.18.1

Reflection alternatives and similar libraries

Based on the "Reflection" category.
Alternatively, view Reflection alternatives based on common mentions on social networks and blogs.

Do you think we are missing an alternative of Reflection or a related project?

Add another 'Reflection' Library


Reflection [DEPRECATED]

Swift License Slack Travis Codecov Codebeat

Reflection provides an API for advanced reflection at runtime including dynamic construction of types.


import Reflection

struct Person {
  var firstName: String
  var lastName: String
  var age: Int

// Reflects the instance properties of type `Person`
let props = try properties(Person.self)

var person = Person(firstName: "John", lastName: "Smith", age: 35)

// Retrieves the value of `person.firstName`
let firstName: String = try get("firstName", from: person)

// Sets the value of `person.age`
try set(36, key: "age", for: &person)

// Creates a `Person` from a dictionary
let friend: Person = try construct(dictionary: ["firstName" : "Sarah",
                                                "lastName" : "Gates",
                                                "age" : 28])


import PackageDescription

let package = Package(
    dependencies: [
        .Package(url: "https://github.com/Zewo/Reflection.git", majorVersion: 0, minor: 15),

Advanced Usage

// `Reflection` can be extended for higher-level packages to do mapping and serializing.
// Here is a simple `Mappable` protocol that allows deserializing of arbitrary nested structures.

import Reflection

typealias MappableDictionary = [String : Any]

enum Error : ErrorProtocol {
    case missingRequiredValue(key: String)

protocol Mappable {
    init(dictionary: MappableDictionary) throws

extension Mappable {

    init(dictionary: MappableDictionary) throws {
        self = try construct { property in
            if let value = dictionary[property.key] {
                if let type = property.type as? Mappable.Type, let value = value as? MappableDictionary {
                    return try type.init(dictionary: value)
                } else {
                    return value
            } else {
                throw Error.missingRequiredValue(key: property.key)


struct Person : Mappable {
    var firstName: String
    var lastName: String
    var age: Int
    var phoneNumber: PhoneNumber

struct PhoneNumber : Mappable {
    var number: String
    var type: String

let dictionary = [
    "firstName" : "Jane",
    "lastName" : "Miller",
    "age" : 54,
    "phoneNumber" : [
        "number" : "924-555-0294",
        "type" : "work"
    ] as MappableDictionary
] as MappableDictionary

let person = try Person(dictionary: dictionary)


If you need any help you can join our Slack and go to the #help channel. Or you can create a Github issue in our main repository. When stating your issue be sure to add enough details, specify what module is causing the problem and reproduction steps.



The entire Zewo code base is licensed under MIT. By contributing to Zewo you are contributing to an open and engaged community of brilliant Swift programmers. Join us on Slack to get to know us!


This project is released under the MIT license. See [LICENSE](LICENSE) for details.

*Note that all licence references and agreements mentioned in the Reflection README section above are relevant to that project's source code only.