Ideas about global storage

[bwetherfield]

I wonder if the following could be of use, @jsbean ?

struct Prism <A,B> {
    let unwrap: (A) -> B?
    let wrap: (B) -> A
}

enum Music {
    
    static var objects: [Music] = []
    
    case duration(Duration)
    case pitch(Pitch)
...
}

extension Music {
    enum prism {
        static let duration = Prism<Music, Duration>(
            unwrap: {
                if case let .duration(object) = $0 { return object }
                return nil
            },
            wrap: Music.duration
        )
        
        static let pitch = Prism<Music, Pitch>(
            unwrap: {
                if case let .pitch(object) = $0 { return object }
                return nil
            },
            wrap: Music.pitch
        )
    }
...
}

extension Music {

    func allDurations() -> [Duration] {
        return Music.objects.compactMap(Music.prism.duration.unwrap)
    }
    
    func allPitches() -> [Pitch] {
        return Music.objects.compactMap(Music.prism.pitch.unwrap)
    }
}