// Get container instance...
let container = Container()
// ...and access some feature or property, it will be initialized if needed.
// Here we use timestamp - access current system time - we are able to easily access it...
let timestamp = container.timestamp.now
// ...and swap it if needed for mocking or testing.
container.timestamp = .constant(0)
// Then you use the new one through container in each places at once.
let constant = container.timestamp.now

// Define property and its value type, it can be property itself.
enum SomeProperty: Property {
  // All you need is to give it some default value.
  // It can be nil for optionals.
  static var defaultValue: Int = 42
}

// Then get some property container...
let container = Container()
// ...and access property value
let defaultValue = container[SomeProperty.self]
container[SomeProperty.self] = 7
let previouslySet = container[SomeProperty.self]

// You can improve that by extending PropertyContainer with your property like so:
extension PropertyContainer {
  
  var someProperty: SomeProperty {
    get { self[SomeProperty.self] }
    set { self[SomeProperty.self] = newValue }
  }
}
// Which gives you more natural and fluent access
let value = container.someProperty // accessing same property as before
container.someProperty = 1 // and you can also set values

// You can also define lazily initialized features
// which will be loaded in container context.
// Feature instance type can be also any type or Feature itself.
struct SomeFeature: Feature {
  // Here we use some property as example
  var answer: Int
  // All you need is to define how to initialize feature instance
  // Since you have access to container you can use any property
  // or other feature to initialize 
  // It can be a nice solution for dependency injection since you can
  // always swap implementation in needed
  static func load(in container: FeatureContainer) -> SomeFeature {
    .init(answer: container[SomeProperty.self])
  }
}
// Then you can access it in the same way as property
// and extend FeatureContainer to give it a nicer access
extension FeatureContainer {
  
  var someFeature: SomeFeature {
    get { self[SomeFeature.self] }
    set { self[SomeFeature.self] = newValue }
  }
}
// Here it is - lazily initialized, using other values from container
let answerFromFeature = container.someFeature.answer

// Additionally you can observe both property and feature changes in container
let cancelation = container.observe(SomeProperty.self) { newValue in
  // get notified on each value change
}
// You can cancel observation at any time by using returned cancellable