How to enumerate an enum with String type

Question

enum Suit  String       case spades           case hearts           case diamonds           case clubs           For example  how can I do something like   for suit in Suit          do something with suit     print suit rawValue      Resulting example

User · Answer

Updated Code   Swift 4 2 Swift 5 enum Suit  String  CaseIterable      case spades    quot   quot     case hearts    quot   quot     case diamonds    quot   quot     case clubs    quot   quot     To access the Output as per question  for suitKey in Suit allCases       print suitKey rawValue     Output            CaseIterable  provides a collection of all of its values  Types that conform to the CaseIterable protocol are typically enumerations without associated values  When using a CaseIterable type  you can access a collection of all of the type   s cases by using the type   s allCases property  For accessing cases we are using  allCases  For more information click https   developer apple com documentation swift caseiterable

User · Answer

I did it using computed property  which returns the array of all values  thanks to this post http   natecook com blog 2014 10 loopy-random-enum-ideas    However  it also uses int raw-values  but I don t need to repeat all members of enumeration in separate property    UPDATE Xcode 6 1 changed a bit a way how to get enum member using rawValue  so I fixed listing  Also fixed small error with wrong first rawValue   enum ValidSuits  Int       case Clubs   0  Spades  Hearts  Diamonds     func description   - gt  String           switch self           case  Clubs              return              case  Spades              return              case  Diamonds              return              case  Hearts              return                           static var allSuits   ValidSuits            return Array              SequenceOf                      - gt  GeneratorOf lt ValidSuits gt  in                 var i 0                 return GeneratorOf lt ValidSuits gt                        return ValidSuits rawValue  i

User · Answer

I made a utility function iterateEnum   for iterating cases for arbitrary enum types   Here is the example usage   enum Suit  String       case Spades           case Hearts           case Diamonds           case Clubs          for f in iterateEnum Suit        println f rawValue      Which outputs             But  this is only for debug or test purposes  This relies on several undocumented Swift1 1 compiler behaviors  so  use it at your own risk   Here is the code   func iterateEnum lt T  Hashable gt     T Type  - gt  GeneratorOf lt T gt        var cast   Int - gt  T       switch sizeof T            case 0  return GeneratorOf GeneratorOfOne unsafeBitCast     T self            case 1  cast     unsafeBitCast UInt8 truncatingBitPattern   0   T self            case 2  cast     unsafeBitCast UInt16 truncatingBitPattern   0   T self            case 4  cast     unsafeBitCast UInt32 truncatingBitPattern   0   T self            case 8  cast     unsafeBitCast UInt64  0   T self            default  fatalError  cannot be here              var i   0     return GeneratorOf           let next   cast i          return next hashValue    i     next   nil           The underlying idea is    Memory representation of enum   excluding enums with associated types   is just an index of cases when the count of the cases is 2   256  it s identical to UInt8  when 257   65536  it s UInt16 and so on  So  it can be unsafeBitcast from corresponding unsigned integer types   hashValue of enum values is the same as the index of the case   hashValue of enum values bitcasted from invalid index is 0      Revised for Swift2 and implemented casting ideas from  Kametrixom s answer   func iterateEnum lt T  Hashable gt     T Type  - gt  AnyGenerator lt T gt        var i   0     return anyGenerator           let next   withUnsafePointer  amp i    UnsafePointer lt T gt   0  memory           return next hashValue    i     next   nil             Revised for Swift3   func iterateEnum lt T  Hashable gt     T Type  - gt  AnyIterator lt T gt        var i   0     return AnyIterator           let next   withUnsafePointer to   amp i                 0 withMemoryRebound to  T self  capacity  1     0 pointee                     if next hashValue    i   return nil           i    1         return next             Revised for Swift3 0 1   func iterateEnum lt T  Hashable gt     T Type  - gt  AnyIterator lt T gt        var i   0     return AnyIterator           let next   withUnsafeBytes of   amp i     0 load as  T self            if next hashValue    i   return nil           i    1         return next

User · Answer

Sorry  my answer was specific to how I used this post in what I needed to do   For those who stumble upon this question  looking for a way to find a case within an enum  this is the way to do it  new in Swift 2    Edit  lowercase camelCase is now the standard for Swift 3 enum values     From apple docs  If the raw-value type is specified as String and you don   t assign values to the cases explicitly  each unassigned case is implicitly assigned a string with the same text as the name of that case   enum Theme  String           case white  blue  green  lavender  grey        func loadTheme theme  String               this checks the string against the raw value of each enum case  note that the check could result in a nil value  since it s an optional  which is why we introduce the if let block     if let testTheme   Theme rawValue  theme                       testTheme is guaranteed to have an enum value at this point         self someOtherFunction testTheme                    For those wondering about the enumerating on an enum  the answers given on this page that include a static var let containing an array of all enum values are correct   The latest Apple example code for tvOS contains this exact same technique   That being said  they should build a more convenient mechanism into the language  Apple  are you listening

User · Answer

This is a pretty old post  from Swift 2 0  There are now some better solutions here that use newer features of swift 3 0  Iterating through an Enum in Swift 3 0  And on this question there is a solution that uses a new feature of  the not-yet-released as I write this edit  Swift 4 2  How do I get the count of a Swift enum     There are lots of good solutions in this thread and others however some of them are very complicated  I like to simplify as much as possible  Here is a solution which may or may not work for different needs but I think it works well in most cases    enum Number  String       case One     case Two     case Three     case Four     case EndIndex      func nextCase    - gt  Number               switch self           case  One              return  Two         case  Two              return  Three         case  Three              return  Four         case  Four              return  EndIndex                      Add all additional cases above                    case  EndIndex              return  EndIndex                      static var allValues   String            var array   String    Array           var number   Number One          while number    Number EndIndex               array append number rawValue              number   number nextCase                     return array           To iterate   for item in Number allValues       print  number is    item

User · Answer

Swift 5 Solution   enum Suit  String  CaseIterable       case spades           case hearts           case diamonds           case clubs             access cases like this   for suitKey in Suit allCases       print suitKey

User · Answer

This problem is now much easier  Here is my Swift 4 2 Solution   enum Suit  Int  CaseIterable     case None   case Spade  Heart  Diamond  Club    static let allNonNullCases   Suit allCases Spade rawValue        enum Rank  Int  CaseIterable     case Joker   case Two  Three  Four  Five  Six  Seven  Eight   case Nine  Ten  Jack  Queen  King  Ace    static let allNonNullCases   Rank allCases Two rawValue        func makeDeck withJoker  Bool   false  - gt   Card      var deck    Card      for suit in Suit allNonNullCases       for rank in Rank allNonNullCases         deck append Card suit  suit  rank  rank               if withJoker       deck append Card suit   None  rank   Joker         return deck     Pre 4 2   I like this solution which I put together after finding  List comprehension in Swift    It uses Int raws instead of Strings but it avoids typing twice  it allows customizing the ranges  and doesn t hard code raw values   This is a Swift 4 version of my original solution but see the 4 2 improvement above   enum Suit  Int     case None   case Spade  Heart  Diamond  Club    static let allRawValues   Suit Spade rawValue   Suit Club rawValue   static let allCases   Array allRawValues map  Suit rawValue   0        enum Rank  Int     case Joker   case Two  Three  Four  Five  Six   case Seven  Eight  Nine  Ten   case Jack  Queen  King  Ace    static let allRawValues   Rank Two rawValue   Rank Ace rawValue   static let allCases   Array allRawValues map  Rank rawValue   0        func makeDeck withJoker  Bool   false  - gt   Card      var deck    Card      for suit in Suit allCases       for rank in Rank allCases         deck append Card suit  suit  rank  rank               if withJoker       deck append Card suit   None  rank   Joker         return deck

User · Answer

Another solution    enum Suit  String       case spades           case hearts           case diamonds           case clubs            static var count  Int           return 4               init index  Int            switch index               case 0  self    spades             case 1  self    hearts             case 2  self    diamonds             default  self    clubs                    for i in 0   lt Suit count       print Suit index  i  rawValue

User · Answer

You can try to enumerate like this  enum Planet  String       case Mercury     case Venus     case Earth     case Mars      static var enumerate   Planet            var a   Planet               switch Planet Mercury               case  Mercury  a append  Mercury   fallthrough             case  Venus  a append  Venus   fallthrough             case  Earth  a append  Earth   fallthrough             case  Mars  a append  Mars                return a          Planet enumerate     Mercury  Venus  Earth  Mars

User · Answer

enum Rank  Int       case Ace   1     case Two  Three  Four  Five  Six  Seven  Eight  Nine  Ten     case Jack  Queen  King      func simpleDescription   - gt  String           switch self           case  Ace  return  ace          case  Jack  return  jack          case  Queen  return  queen          case  King  return  king          default  return String self toRaw                       enum Suit  Int       case Spades   1     case Hearts  Diamonds  Clubs      func simpleDescription   - gt  String           switch self           case  Spades  return  spades          case  Hearts  return  hearts          case  Diamonds  return  diamonds          case  Clubs  return  clubs                       func color   - gt  String           switch self           case  Spades   Clubs  return  black          case  Hearts   Diamonds  return  red                     struct Card       var rank  Rank     var suit  Suit     func simpleDescription   - gt  String           return  The   rank simpleDescription    of   suit simpleDescription                static func createPokers   - gt  Card             let ranks   Array Rank Ace toRaw     Rank King toRaw            let suits   Array Suit Spades toRaw     Suit Clubs toRaw            let cards   suits reduce Card         tempCards  suit  in             tempCards   ranks map   rank in                 Card rank  Rank fromRaw rank    suit  Suit fromRaw suit                                    return cards

User · Answer

You could iterate through an enum by implementing the ForwardIndexType protocol   The ForwardIndexType protocol requires you to define a successor   function to step through the elements   enum Rank  Int  ForwardIndexType       case Ace   1     case Two  Three  Four  Five  Six  Seven  Eight  Nine  Ten     case Jack  Queen  King             other functions         Option 1 - Figure it out by hand     func successor   - gt  Rank           switch self               case  Ace                return  Two             case  Two                return  Three                     etc               default                return  King                         Option 2 - Define an operator      func successor   - gt  Rank           return self   1             NOTE  The operator is defined OUTSIDE the class func    left  Rank  right  Int  - gt  Rank          I m using to from raw here  but again  you can use a case statement        or whatever else you can think of      return left     King    King   Rank rawValue  left rawValue   right       Iterating over an open or closed range     lt  or      will internally call the successor   function which allows you to write this      Under the covers  successor Rank King  and successor Rank Ace  are called to establish limits for r in Rank Ace   Rank King          Do something useful

User · Answer

EDIT  Swift Evolution Proposal SE-0194 Derived Collection of Enum Cases proposes a level headed solution to this problem  We see it in Swift 4 2 and newer  The proposal also points out to some workarounds that are similar to some already mentioned here but it might be interesting to see nevertheless   I will also keep my original post for completeness  sake     This is yet another approach based on  Peymmankh s answer  adapted to Swift 3   public protocol EnumCollection  Hashable     extension EnumCollection    public static func allValues   - gt   Self        typealias S   Self      let retVal   AnySequence      - gt  AnyIterator lt S gt  in         var raw   0         return AnyIterator               let current   withUnsafePointer to   amp raw                      0 withMemoryRebound to  S self  capacity  1     0 pointee                             guard current hashValue    raw else   return nil               raw    1             return current                      return  S  retVal

User · Answer

Enums have toRaw   and fromRaw   methods  So if your raw value is an Int  you can iterate from the first to last enum   enum Suit  Int       case Spades   1     case Hearts  Diamonds  Clubs     func simpleDescription   - gt  String           switch self           case  Spades              return  spades          case  Hearts              return  hearts          case  Diamonds              return  diamonds          case  Clubs              return  clubs                     for i in Suit Spades toRaw     Suit Clubs toRaw         if let covertedSuit   Suit fromRaw i            let description   covertedSuit simpleDescription             One gotcha is that you need to test for optional values before running the simpleDescription method  so we set convertedSuit to our value first and then set a constant to convertedSuit simpleDescription

User · Answer

In principle it is possible to do it this way assuming that you don t use raw values assignment for enum s cases   enum RankEnum  Int     case Ace   case One   case Two    class RankEnumGenerator  Generator       var i   0     typealias Element   RankEnum     func next   - gt  Element            let r   RankEnum fromRaw i          i    1         return r          extension RankEnum       static func enumerate   - gt  SequenceOf lt RankEnum gt            return SequenceOf lt RankEnum gt    RankEnumGenerator               for r in RankEnum enumerate         println    r toRaw

User · Answer

Updated to Swift 2 2   func iterateEnum lt T  Hashable gt     T Type  - gt  AnyGenerator lt T gt        var i   0     return AnyGenerator           let next   withUnsafePointer  amp i                UnsafePointer lt T gt   0  memory                   if next hashValue    i               i    1             return next           else               return nil                     It s updated code to Swift 2 2 form  Kametrixom s answer  For Swift 3 0   many thanks to  Philip   func iterateEnum lt T  Hashable gt     T Type  - gt  AnyIterator lt T gt        var i   0     return AnyIterator           let next   withUnsafePointer  amp i                UnsafePointer lt T gt   0  pointee                   if next hashValue    i               i    1             return next           else               return nil

User · Answer

While dealing with Swift 2 0 here is my suggestion   I have added the raw type to Suit enum   enum Suit  Int     then   struct Card       var rank  Rank     var suit  Suit       func fullDeck  - gt   Card             var deck    Card             for i in Rank Ace rawValue   Rank King rawValue                for j in Suit Spades rawValue   Suit Clubs rawValue                    deck append Card rank Rank rawValue  i     suit  Suit rawValue  j                                      return deck

User · Answer

This solution strikes the right balance of readability and maintainability   struct Card                    static func deck   - gt  Card             var deck   Card             for rank in Rank Ace toRaw     Rank King toRaw                 for suit in  Suit Spades   Hearts   Clubs   Diamonds                    let card   Card rank  Rank fromRaw rank    suit  suit                  deck append card                              return deck          let deck   Card deck

User · Answer

Swift 4 2  Starting with Swift 4 2  with Xcode 10   just add protocol conformance to CaseIterable to benefit from allCases  To add this protocol conformance  you simply need to write somewhere  extension Suit  CaseIterable     If the enum is your own  you may specify the conformance directly in the declaration  enum Suit  String  CaseIterable   case spades    quot   quot   case hearts    quot   quot   case diamonds    quot   quot   case clubs    quot   quot     Then the following code will print all possible values  Suit allCases forEach       print  0 rawValue      Compatibility with earlier Swift versions  3 x and 4 x  If you need to support Swift 3 x or 4 0  you may mimic the Swift 4 2 implementation by adding the following code   if  swift  gt  4 2  public protocol CaseIterable       associatedtype AllCases  Collection where AllCases Element    Self     static var allCases  AllCases   get     extension CaseIterable where Self  Hashable       static var allCases   Self            return  Self  AnySequence      - gt  AnyIterator lt Self gt  in             var raw   0             var first  Self              return AnyIterator                   let current   withUnsafeBytes of   amp raw     0 load as  Self self                    if raw    0                       first   current                   else if current    first                       return nil                                   raw    1                 return current                                   endif

User · Answer

I found myself doing  allValues alot throughout my code  I finally figured out a way to simply conform to an Iteratable protocol and have an rawValues   method   protocol Iteratable    extension RawRepresentable where Self  RawRepresentable        static func iterateEnum lt T  Hashable gt     T Type  - gt  AnyIterator lt T gt            var i   0         return AnyIterator               let next   withUnsafePointer to   amp i                     0 withMemoryRebound to  T self  capacity  1     0 pointee                             if next hashValue    i   return nil               i    1             return next                    extension Iteratable where Self  RawRepresentable  Self  Hashable       static func hashValues   - gt  AnyIterator lt Self gt            return iterateEnum self             static func rawValues   - gt   Self RawValue            return hashValues   map   0 rawValue                Example enum Grocery  String  Iteratable       case Kroger    kroger      case HEB    h e b       case Randalls    randalls     let groceryHashes   Grocery hashValues      AnyIterator lt Grocery gt  let groceryRawValues   Grocery rawValues        kroger    h e b     randalls

User · Answer

There is a clever way  and frustrating as it is it illustrates the difference between the two different kinds of enums   Try this       func makeDeck   - gt  Card           var deck  Card              var suits  Suit       Hearts   Diamonds   Clubs   Spades        for i in 1   13           for suit in suits             deck    Card rank  Rank fromRaw i    suit  suit                          return deck         The deal is that an enum backed by numbers  raw values  is implicitly explicitly ordered  whereas an enum that isn t backed by numbers is explicitly implicitly unordered   E g  when we give the enum values numbers  the language is cunning enough to figure out what order the numbers are in  If on the other hand we don t give it any ordering  when we try to iterate over the values the language throws its hands up in the air and goes  yes  but which one do you want to go first      Other languages which can do this  iterating over unordered enums  might be the same languages where everything is  under the hood  actually a map or dictionary  and you can iterate over the keys of a map  whether there s any logical ordering or not   So the trick is to provide it with something that is explicitly ordered  in this case instances of the suits in an array in the order we want   As soon as you give it that  Swift is like  well why didn t you say so in the first place    The other shorthand trick is to use the forcing operator on the fromRaw function   This illustrates another  gotcha  about enums  that the range of possible values to pass in is often larger than the range of enums   For instance if we said Rank fromRaw 60  there wouldn t be a value returned  so we re using the optional feature of the language  and where we start using optionals  forcing will soon follow    Or alternately the if let construction which still seems a bit weird to me

User · Answer

This seems like a hack but if you use raw values you can do something like this  enum Suit  Int         case Spades   0  Hearts  Diamonds  Clubs               var suitIndex   0   while var suit   Suit fromRaw suitIndex

User · Answer

My solution is to declare an array with all the enum possibilities  So for loop can traverse through all of them     Function inside struct Card static func generateFullDeck   - gt   Card        let allRanks    Rank Ace  Rank Two  Rank Three  Rank Four  Rank Five  Rank Six  Rank Seven  Rank Eight  Rank Nine  Rank Ten  Rank Jack  Rank Queen  Rank King      let allSuits    Suit Hearts  Suit Diamonds  Suit Clubs  Suit Spades      var myFullDeck   Card            for myRank in allRanks           for mySuit in allSuits               myFullDeck append Card rank  myRank  suit  mySuit                       return myFullDeck      actual use  let aFullDeck   Card generateFullDeck        Generate the desired full deck  var allDesc   String       for aCard in aFullDeck       println aCard simpleDescription         You ll see all the results in playground

User · Answer

The experiment was   EXPERIMENT  Add a method to Card that creates a full deck of cards  with one card of each combination of rank and suit   So without modifying or enhancing the given code other than adding the method  and without using stuff that hasn t been taught yet   I came up with this solution   struct Card       var rank  Rank     var suit  Suit      func simpleDescription   - gt  String           return  The   rank simpleDescription    of   suit simpleDescription                func createDeck   - gt   Card            var deck   Card               for rank in Rank Ace rawValue   Rank King rawValue               for suit in Suit Spades rawValue   Suit Clubs rawValue                   let card   Card rank  Rank rawValue  rank    suit  Suit rawValue  suit                      println card simpleDescription                    deck     card                                  return deck         let threeOfSpades   Card rank   Three  suit   Spades  let threeOfSpadesDescription   threeOfSpades simpleDescription   let deck   threeOfSpades createDeck

User · Answer

I added function count    and iterate the values   public enum MetricType  Int       case mvps   0     case allNBA   1     case championshipRings   2     case finalAppearances   3     case gamesPlayed   4     case ppg   5      static func count   - gt  Int           return  ppg rawValue    1            static var allValues   MetricType            var array   MetricType    Array           var item   MetricType   MetricType mvps         while item rawValue  lt  MetricType count                 array append item              item   MetricType rawValue   item rawValue   1                  return array

User · Answer

enum Rank  Int       case Ace   0     case Two  Three  Four  Five  Six  Seve  Eight  Nine  Ten     case Jack  Queen  King     case Count    enum Suit   Int       case Spades   0     case Hearts  Diamonds  Clubs     case Count    struct Card       var rank Rank     var suit Suit    class Test       func makeDeck   - gt  Card                 let suitsCount Int   Suit Count toRaw           let rankCount Int   Rank Count toRaw           let repeatedCard Card   Card rank Rank Ace  suit Suit Spades          let deck Card     Card   count suitsCount rankCount  repeatedValue repeatedCard           for i Int in 0  rankCount                       for j Int in 0  suitsCount                               deck i suitsCount j    Card rank  Rank fromRaw i    suit  Suit fromRaw j                                    return deck           Based on Rick answer  this is 5 times faster

User · Answer

Xcode 10 with Swift 4 2 enum Filter  String  CaseIterable        case salary    quot Salary quot      case experience    quot Experience quot      case technology    quot Technology quot      case unutilized    quot Unutilized quot      case unutilizedHV    quot Unutilized High Value quot       static let allValues   Filter allCases map    0 rawValue      Call it print Filter allValues   Prints     quot Salary quot    quot Experience quot    quot Technology quot    quot Unutilized quot    quot Unutilized High Value quot     Older versions For enum representing Int enum Filter  Int       case salary     case experience     case technology     case unutilized     case unutilizedHV          static let allRawValues   salary rawValue   unutilizedHV rawValue     First to last case     static let allValues   allRawValues map   Filter rawValue   0   rawValue      Call it like this  print Filter allValues   Prints    0  1  2  3  4    For enum representing String enum Filter  Int       case salary     case experience     case technology     case unutilized     case unutilizedHV          static let allRawValues   salary rawValue   unutilizedHV rawValue     First to last case     static let allValues   allRawValues map   Filter rawValue   0   description      extension Filter  CustomStringConvertible       var description  String           switch self           case  salary  return  quot Salary quot          case  experience  return  quot Experience quot          case  technology  return  quot Technology quot          case  unutilized  return  quot Unutilized quot          case  unutilizedHV  return  quot Unutilized High Value quot                     Call it print Filter allValues   Prints     quot Salary quot    quot Experience quot    quot Technology quot    quot Unutilized quot    quot Unutilized High Value quot

User · Answer

The other solutions work but they all make assumptions of for example the number of possible ranks and suits  or what the first and last rank may be  True  the layout of a deck of cards probably isn t going to change much in the foreseeable future  In general  however  it s neater to write code which makes as little assumptions as possible  My solution   I ve added a raw type to the Suit enum  so I can use Suit rawValue   to access the Suit cases   enum Suit  Int       case Spades   1     case Hearts  Diamonds  Clubs     func simpleDescription   - gt  String           switch self               case  Spades                  return  spades              case  Hearts                  return  hearts              case  Diamonds                  return  diamonds              case  Clubs                  return  clubs                      func color   - gt  String           switch self           case  Spades              return  black          case  Clubs              return  black          case  Diamonds              return  red          case  Hearts              return  red                     enum Rank  Int       case Ace   1     case Two  Three  Four  Five  Six  Seven  Eight  Nine  Ten     case Jack  Queen  King     func simpleDescription   - gt  String           switch self               case  Ace                  return  ace              case  Jack                  return  jack              case  Queen                  return  queen              case  King                  return  king              default                  return String self rawValue                      Below the implementation of Card s createDeck   method  init rawValue   is a failable initializer and returns an optional  By unwrapping and checking its value in both while statements  there s no need to assume the number of Rank or Suit cases   struct Card       var rank  Rank     var suit  Suit     func simpleDescription   - gt  String           return  The   rank simpleDescription    of   suit simpleDescription               func createDeck   - gt   Card            var n   1         var deck    Card            while let rank   Rank rawValue  n                var m   1             while let suit   Suit rawValue  m                    deck append Card rank  rank  suit  suit                   m    1                           n    1                   return deck           Here is how to call the createDeck method   let card   Card rank  Rank Ace  suit  Suit Clubs  let deck   card createDeck

User · Answer

Improvement on Karthik Kumar answer   This solution is using the compiler to guarantee you won t miss a case   enum Suit  String       case spades           case hearts           case diamonds           case clubs            static var enumerate   Suit            switch Suit spades              make sure the two lines are identical             case         spades   hearts   diamonds   clubs              return   spades   hearts   diamonds   clubs

User · Answer

I found a somewhat hacky-feeling but much safer way of doing this that doesn t require typing the values twice or referencing the memory of the enum values  making it very unlikely to break   Basically  instead of using an enum  make a struct with a single instance  and make all of the enum-values constants  The variables can then be queried using a Mirror  public struct Suit          the values     let spades           let hearts           let diamonds           let clubs               make a single instance of the Suit struct  Suit instance     struct SStruct static var instance  Suit   Suit        static var instance   Suit          get return SStruct instance          set SStruct instance   newValue                an array with all of the raw values     static var allValues   String           var values    String             let mirror   Mirror reflecting  Suit instance          for     v  in mirror children              guard let suit   v as  String else continue              values append suit                     return values           If you use this method  to get a single value you ll need to use Suit instance clubs or Suit instance spades  But all of that is so boring    Let s do some stuff that makes this more like a real enum   public struct SuitType          store multiple things for each suit     let spades   Suit      order  4      let hearts   Suit      order  3      let diamonds   Suit      order  2      let clubs   Suit      order  1       struct SStruct static var instance  SuitType   SuitType        static var instance   SuitType          get return SStruct instance          set SStruct instance   newValue                a dictionary mapping the raw values to the values     static var allValuesDictionary   String   Suit           var values    String   Suit             let mirror   Mirror reflecting  SuitType instance          for     v  in mirror children              guard let suit   v as  Suit else continue              values suit rawValue    suit                    return values          public struct Suit  RawRepresentable  Hashable      public var rawValue  String     public typealias RawValue   String      public var hashValue  Int             find some integer that can be used to uniquely identify            each value  In this case  we could have used the order            variable because it is a unique value  yet to make this            apply to more cases  the hash table address of rawValue            will be returned  which should work in almost all cases                        you could also add a hashValue parameter to init   and            give each suit a different hash value         return rawValue hash            public var order  Int     public init   value  String  order  Int           self rawValue   value         self order   order               an array of all of the Suit values     static var allValues   Suit           var values    Suit             let mirror   Mirror reflecting  SuitType instance          for     v  in mirror children              guard let suit   v as  Suit else continue              values append suit                     return values               allows for using Suit rawValue        like a normal enum     public init  rawValue  String              get the Suit from allValuesDictionary in SuitType  or return nil if that raw value doesn t exist         guard let suit   SuitType allValuesDictionary rawValue  else return nil             initialize a new Suit with the same properties as that with the same raw value         self init suit rawValue  order  suit order            You can now do stuff like  let allSuits   Suit    Suit allValues   or  for suit in Suit allValues     print  The suit   suit rawValue  has the order   suit order        However  To get a single you ll still need to use SuitType instance spades or SuitType instance hearts  To make this a little more intuitive  you could add some code to Suit that allows you to use Suit type   instead of SuitType instance    public struct Suit  RawRepresentable  Hashable           your code        static var type   SuitType instance           more of your code        You can now use Suit type diamonds instead of SuitType instance diamonds  or Suit type clubs instead of SuitType instance clubs

User · Answer

enum Rank  Int               static let ranks    Rank Ace rawValue     Rank King rawValue  map Rank rawValue   0        enum Suit               static let suits    Spades  Hearts  Diamonds  Clubs     struct Card               static func fullDesk   - gt   Card            var desk   Card               for suit in Suit suits               for rank in Rank ranks                   desk append Card rank  rank suit  suit                                   return desk           How about this

User · Answer

Here is a method I use to both iterate an enum and provide multiple values types from one enum  enum IterateEnum  Int       case Zero     case One     case Two     case Three     case Four     case Five     case Six     case Seven        tuple allows multiple values to be derived from the enum case  and       since it is using a switch with no default  if a new case is added        a compiler error will be returned if it doesn t have a value tuple set     var value   french  String  spanish  String  japanese  String            switch self           case  Zero  return  french   z  ro   spanish   cero   japanese   nuru           case  One  return  french   un   spanish   uno   japanese   ichi           case  Two  return  french   deux   spanish   dos   japanese   ni           case  Three  return  french   trois   spanish   tres   japanese   san           case  Four  return  french   quatre   spanish   cuatro   japanese   shi           case  Five  return  french   cinq   spanish   cinco   japanese   go           case  Six  return  french   six   spanish   seis   japanese   roku           case  Seven  return  french   sept   spanish   siete   japanese   shichi                          Used to iterate enum or otherwise access enum case by index order        Iterate by looping until it returns nil     static func item index  Int  - gt  IterateEnum            return IterateEnum init rawValue  index             static func numberFromSpanish number  String  - gt  IterateEnum            return findItem    0 value spanish    number                use block to test value property to retrieve the enum case             static func findItem predicate       IterateEnum  - gt  Bool   - gt  IterateEnum             var enumIndex  Int   -1         var enumCase  IterateEnum             Iterate until item returns nil         repeat               enumIndex    1             enumCase   IterateEnum item index  enumIndex               if let eCase   enumCase                    if predicate eCase                        return eCase                                           while enumCase    nil         return nil          var enumIndex  Int   -1 var enumCase  IterateEnum      Iterate until item returns nil repeat       enumIndex    1     enumCase   IterateEnum item index  enumIndex      if let eCase   enumCase           print  The number   eCase  in french    eCase value french   spanish    eCase value spanish   japanese    eCase value japanese            while enumCase    nil  print  Total of   enumIndex  cases    let number   IterateEnum numberFromSpanish number   siete    print  siete in japanese     number  value japanese     Unknown        This is the output   The number Zero in french  z  ro  spanish  cero  japanese  nuru The number One in french  un  spanish  uno  japanese  ichi The number Two in french  deux  spanish  dos  japanese  ni The number Three in french  trois  spanish  tres  japanese  san The number Four in french  quatre  spanish  cuatro  japanese  shi The number Five in french  cinq  spanish  cinco  japanese  go The number Six in french  six  spanish  seis  japanese  roku The number Seven in french  sept  spanish  siete  japanese  shichi  Total of 8 cases  siete in japanese  shichi    UPDATE  I recently created a protocol to handle the enumeration   The protocol requires an enum with an Int raw value   protocol EnumIteration          Used to iterate enum or otherwise access enum case by index order  Iterate by looping until it returns nil      static func item index Int  - gt  Self      static func iterate item   index Int  enumCase Self - gt      completion    - gt             static func findItem predicate   enumCase Self - gt Bool   - gt  Self      static func count   - gt  Int    extension EnumIteration where Self  RawRepresentable  Self RawValue    Int          Used to iterate enum or otherwise access enum case by index order  Iterate by looping until it returns nil     static func item index Int  - gt  Self            return Self init rawValue  index             static func iterate item   index Int  enumCase Self - gt      completion    - gt                  var enumIndex Int   -1         var enumCase Self             Iterate until item returns nil         repeat               enumIndex    1             enumCase   Self item enumIndex               if let eCase   enumCase                   item index  enumIndex  enumCase  eCase                          while enumCase    nil         completion               static func findItem predicate   enumCase Self - gt Bool   - gt  Self             var enumIndex Int   -1         var enumCase Self             Iterate until item returns nil         repeat               enumIndex    1             enumCase   Self item enumIndex               if let eCase   enumCase                    if predicate enumCase eCase                        return eCase                                           while enumCase    nil         return nil            static func count   - gt  Int           var enumIndex Int   -1         var enumCase Self             Iterate until item returns nil         repeat               enumIndex    1             enumCase   Self item enumIndex            while enumCase    nil            last enumIndex  when enumCase    nil  is equal to the enum count         return enumIndex

User · Answer

As with  Kametrixom answer here I believe returning an array would be better than returning AnySequence  since you can have access to all of Array s goodies such as count  etc   Here s the re-write   public protocol EnumCollection   Hashable    extension EnumCollection       public static func allValues   - gt   Self            typealias S   Self         let retVal   AnySequence      - gt  AnyGenerator lt S gt  in             var raw   0             return AnyGenerator                   let current   Self   withUnsafePointer  amp raw    UnsafePointer  0  memory                   guard current hashValue    raw else   return nil                   raw    1                 return current                                  return  S  retVal

User · Answer

Here s my suggested approach  It s not completely satisfactory  I m very new to Swift and OOP   but maybe someone can refine it  The idea is to have each enum provide its own range information as  first and  last properties  It adds just two lines of code to each enum  still a bit hard-coded  but at least it s not duplicating the whole set  It does require modifying the Suit enum to be an Int like the Rank enum is  instead of untyped    Rather than echo the whole solution  here s the code I added to the   enum  somewhere after the case statements  Suit enum is similar    var first  Int   return Ace toRaw     var last  Int   return King toRaw       and the loop I used to build the deck as an array of String   The problem definition did not state how the deck was to be structured    func createDeck   - gt   String        var deck   String           var card  String     for r in Rank Ace first   Rank Ace last           for s in Suit Hearts first   Suit Hearts last               card   Rank simpleDescription  Rank fromRaw r          of     Suit simpleDescription  Suit fromRaw s                 deck append  card                     return deck     It s unsatisfactory because the properties are associated to an element rather than to the enum  But it does add clarity to the  for  loops  I d like it to say Rank first instead of Rank Ace first  It works  with any element   but it s ugly  Can someone show how to elevate that to the enum level   And to make it work  I lifted the createDeck method out of the Card struct  I could not figure out how to get a  String  array returned from that struct  and that seems a bad place to put such a method anyway

User · Answer

This post is relevant here https   www swift-studies com blog 2014 6 10 enumerating-enums-in-swift  Essentially the proposed solution is  enum ProductCategory   String        case Washers    washers   Dryers    dryers   Toasters    toasters        static let allValues    Washers  Dryers  Toasters     for category in ProductCategory allValues         Do something

User · Answer

I stumbled around in the bits and bytes and created an extension that I later found out works very similar to  rintaro s answer  It s used like this   enum E   EnumCollection       case A  B  C    Array E cases           A  B  C    What s remarkable is that it s usable on any enum without associated values  Note that this doesn t work for enums that have no cases   As with  rintaro s answer  this code uses the underlying representation of an enum  This representation isn t documented and might change in the future  which would break it   I don t recommend the usage of this in production    Code  Swift 2 2  Xcode 7 3 1  not working on Xcode 10    protocol EnumCollection   Hashable    extension EnumCollection       static func cases   - gt  AnySequence lt Self gt            typealias S   Self         return AnySequence      - gt  AnyGenerator lt S gt  in             var raw   0             return AnyGenerator                   let current   Self   withUnsafePointer  amp raw    UnsafePointer  0  memory                   guard current hashValue    raw else   return nil                   raw    1                 return current                                   Code  Swift 3  Xcode 8 1  not working on Xcode 10    protocol EnumCollection   Hashable    extension EnumCollection       static func cases   - gt  AnySequence lt Self gt            typealias S   Self         return AnySequence      - gt  AnyIterator lt S gt  in             var raw   0             return AnyIterator                   let current   Self   withUnsafePointer to   amp raw     0 withMemoryRebound to  S self  capacity  1     0 pointee                     guard current hashValue    raw else   return nil                   raw    1                 return current                                   I have no idea why I need typealias  but the compiler complains without it

User · Answer

Here s a less cryptic example if you still wanted to use enums for Rank And Suit   Just collect them into an Array if you want to use a for-in loop to iterate over each one   Example of a standard 52-card deck   enum Rank  Int       case Ace   1  Two  Three  Four  Five  Six  Seven  Eight  Nine  Ten  Jack  Queen  King     func name   - gt  String           switch self           case  Ace              return  ace          case  Jack              return  jack          case  Queen              return  queen          case  King              return  king          default              return String self toRaw                       enum Suit  Int       case Diamonds   1  Clubs  Hearts  Spades     func name   - gt  String           switch self           case  Diamonds              return  diamonds          case  Clubs              return  clubs          case  Hearts              return  hearts          case  Spades              return  spades          default              return  NOT A VALID SUIT                     let Ranks         Rank Ace      Rank Two      Rank Three      Rank Four      Rank Five      Rank Six      Rank Seven      Rank Eight      Rank Nine      Rank Ten      Rank Jack      Rank Queen      Rank King    let Suits         Suit Diamonds      Suit Clubs      Suit Hearts      Suit Spades     class Card       var rank  Rank     var suit  Suit      init rank  Rank  suit  Suit            self rank   rank         self suit   suit          class Deck       var cards   Card          init             for rank in Ranks               for suit in Suits                   cards append Card rank  rank  suit  suit                                    var myDeck   Deck   myDeck cards count       gt  52

User · Answer

On Swift  enum types can be accessed like EnumType Case   let tableView   UITableView frame  self view bounds  style  UITableViewStyle Plain   Most of the time you re only going to use enum types when you have a few options to work with  and know exactly what you re going to do on each one   It wouldn t make much sense to use the for-in structure when working with enum types   You can do this  for instance   func sumNumbers numbers   Int     - gt  Int       var sum   0      for number in numbers          sum    number            return sum

User · Answer

I have used the below method  the assumption is that I know which is the last value in the Rank enum and all the ranks have incremental values after Ace  I prefer this way as it is clean and small  easy to understand   func cardDeck   - gt  Card          var cards  Card             let minRank   Rank Ace toRaw        let maxRank   Rank King toRaw         for rank in minRank   maxRank            if var convertedRank  Rank   Rank fromRaw rank                 cards append Card rank  convertedRank  suite  Suite Clubs                cards append Card rank  convertedRank  suite  Suite Diamonds                cards append Card rank  convertedRank  suite  Suite Hearts                cards append Card rank  convertedRank  suite  Suite Spades                         return cards

User · Answer

Sometimes  you may deal with an enumerated type with an underlying raw integer type that changes throughout the software development lifecycle   Here is an example that works well for that case   public class MyClassThatLoadsTexturesEtc                     Colors used for gems and sectors      public enum Color  Int                  Colors arranged in order of the spectrum          case First   0         case Red  Orange  Yellow  Green  Blue  Purple  Pink            -- gt  Add more colors here  between the first and last markers          case Last                       public func preloadGems                    Preload all gems          for i in  Color First toRaw     1     lt   Color Last toRaw                          let color   Color fromRaw i               loadColoredTextures forKey  color

User · Answer

If you give the enum a raw Int value it will make looping much easier   For example  you can use anyGenerator to get a generator that can enumerate across your values   enum Suit  Int  CustomStringConvertible       case Spades  Hearts  Diamonds  Clubs     var description  String           switch self           case  Spades    return  Spades          case  Hearts    return  Hearts          case  Diamonds  return  Diamonds          case  Clubs     return  Clubs                      static func enumerate   - gt  AnyGenerator lt Suit gt            var nextIndex   Spades rawValue         return anyGenerator   Suit rawValue  nextIndex                 You can now use it like this  for suit in Suit enumerate         suit description      or like this  let allSuits   Suit    Array Suit enumerate        However  this looks like a fairly common pattern  wouldn t it be nice if we could make any enum type enumerable by simply conforming to a protocol  Well with Swift 2 0 and protocol extensions  now we can   Simply add this to your project   protocol EnumerableEnum       init  rawValue  Int      static func firstValue   - gt  Int   extension EnumerableEnum       static func enumerate   - gt  AnyGenerator lt Self gt            var nextIndex   firstRawValue           return anyGenerator   Self rawValue  nextIndex                static func firstRawValue   - gt  Int   return 0       Now any time you create an enum  so long as it has an Int raw value   you can make it enumerable by conforming to the protocol   enum Rank  Int  EnumerableEnum       case Ace  Two  Three  Four  Five  Six  Seven  Eight  Nine  Ten  Jack  Queen  King          for rank in Rank enumerate             If your enum values don t start with 0  the default   override the firstRawValue method   enum DeckColor  Int  EnumerableEnum       case Red   10  Blue  Black     static func firstRawValue   - gt  Int   return Red rawValue            let colors   Array DeckColor enumerate        The final Suit class  including replacing simpleDescription with the more standard CustomStringConvertible protocol  will look like this   enum Suit  Int  CustomStringConvertible  EnumerableEnum       case Spades  Hearts  Diamonds  Clubs     var description  String           switch self           case  Spades    return  Spades          case  Hearts    return  Hearts          case  Diamonds  return  Diamonds          case  Clubs     return  Clubs                           for suit in Suit enumerate         print suit description        Swift 3 syntax   protocol EnumerableEnum       init  rawValue  Int      static func firstRawValue   - gt  Int    extension EnumerableEnum       static func enumerate   - gt  AnyIterator lt Self gt            var nextIndex   firstRawValue            let iterator  AnyIterator lt Self gt    AnyIterator               defer   nextIndex   nextIndex   1               return Self rawValue  nextIndex                     return iterator            static func firstRawValue   - gt  Int           return 0

User · Answer

It took me a little more than just one method in the struct like the swift book called for but I set up next functions in the enum  I would have used a protocol I m not sure why but having rank set as int messes it up   enum Rank  Int       case Ace   1     case Two  Three  Four  Five  Six  Seven  Eight  Nine  Ten     case Jack  Queen  King     func simpleDescription   - gt  String           switch self           case  Ace              return  ace          case  Jack              return  jack          case  Queen              return  Queen          case  King              return  King          default              return String self toRaw                        mutating func next   - gt  Rank           var rank   self         var rawrank   rank toRaw           var nrank  Rank   self         rawrank   rawrank   1         if let newRank   Rank fromRaw rawrank                println    newRank simpleDescription                  nrank   newRank           else               return self                   return nrank          enum Suit       case Spades  Hearts  Diamonds  Clubs     func color   - gt  String           switch self           case  Spades   Clubs              return  black          default              return  red                      func simpleDescription   - gt  String           switch self           case  Spades              return  spades          case  Hearts              return  hearts          case  Diamonds              return  diamonds          case  Clubs              return  clubs                      mutating func next   - gt  Suit           switch self           case  Spades              return Hearts         case  Hearts              return Diamonds         case  Diamonds              return Clubs         case  Clubs              return Spades                    struct Card       var rank  Rank     var suit  Suit     func deck   - gt  Card             var tRank   self rank         var tSuit   self suit         let tcards   52    we start from 0         var cards  Card                for i in 0  tcards               var card   Card rank  tRank  suit  tSuit              cards append card              tRank   tRank next               tSuit   tSuit next                     return cards           func simpleDescription   - gt  String           return  The   rank simpleDescription    of   suit simpleDescription              var card   Card rank   Ace  suit   Spades  var deck   card deck     I used a little general knowledge but that can be easily rectified by multiplying suits by rank  if you aren t using a standard deck of cards and you d have to change the enums accordingly and if basically just steps through the different enums  To save time I used ranks rawValues you could do the same for suits if you wanted  However  the example did not have it so I decided to figure it out without changing suits rawValue

User · Answer

In Swift 3  when the underlying enum has rawValue  you could implement the Strideable protocol   The advantages are that no arrays of values are created like in some other suggestions and that the standard Swift  for in  loop works  which makes a nice syntax       Int  to get rawValue  and Strideable so we can iterate enum MyColorEnum  Int  Strideable       case Red     case Green     case Blue     case Black         required by Strideable     typealias Stride   Int      func advanced by n Stride  - gt  MyColorEnum           var next   self rawValue   n         if next  gt  MyColorEnum Black rawValue               next   MyColorEnum Black rawValue                   return MyColorEnum rawValue  next              func distance to other  MyColorEnum  - gt  Int           return other rawValue - self rawValue               just for printing     func simpleDescription   - gt  String           switch self           case  Red  return  Red          case  Green  return  Green          case  Blue  return  Blue          case  Black  return  Black                        this is how you use it  for i in MyColorEnum Red     MyColorEnum Black       print  ENUM    i

[swift] How to enumerate an enum with String type?

Examples related to swift

Examples related to string

Examples related to enums

Examples related to enumerate