Changeset 8a81b09

Timestamp:

Dec 16, 2020, 3:47:12 PM (2 years ago)

Author:

Colby Alexander Parsons <caparsons@…>

Branches:

ADT, arm-eh, enum, forall-pointer-decay, jacob/cs343-translation, master, new-ast-unique-expr, pthread-emulation, qualifiedEnum

Children:

accc5dbb

Parents:

d25b2d6

Message:

fixed iterators after breaking them

File:

• libcfa/src/bits/sequence.hfa (modified) (1 diff)

libcfa/src/bits/sequence.hfa

@@ -216 +216 @@
 } // distribution
 
-// forall( dtype T ) {
-//      // SeqIter(T) is used to iterate over a Sequence(T) in head-to-tail order.
-//      struct SeqIter {
-//              inline ColIter;
-//              // The Sequence must be passed to pred and succ to check for the end of the Sequence and return 0p. Without
-//              // passing the sequence, traversing would require its length. Thus the iterator needs a pointer to the sequence
-//              // to pass to succ/pred. Both stack and queue just encounter 0p since the lists are not circular.
-//              Sequence(T) * seq;                                                              // FIX ME: cannot be reference
-//      };
-
-//      static inline {
-//              void ?{}( SeqIter(T) & si ) with( si ) {
-//                      ((ColIter &)si){};
-//                      seq = 0p;
-//              } // post: elts = null.
-
-//              void ?{}( SeqIter(T) & si, Sequence(T) & s ) with( si ) {
-//                      ((ColIter &)si){};
-//                      seq = &s;
-//                      curr = &head( s );
-//              } // post: elts = null.
-
-//              void ?{}( SeqIter(T) & si, Sequence(T) & s, T & start ) with( si ) {
-//                      ((ColIter &)si){};
-//                      seq = &s;
-//                      curr = &start;
-//              } // post: elts = null.
-
-//              void over( SeqIter(T) & si, Sequence(T) & s ) with( si ) {
-//                      seq = &s;
-//                      curr = &head( s );
-//              } // post: elts = {e in s}.
-
-//              bool ?>>?( SeqIter(T) & si, T && tp ) with( si ) {
-//                      if ( curr ) {
-//                              &tp = Curr( si );
-//                              T * n = succ( *seq, Curr( si ) );
-//                              curr = n == &head( *seq ) ? 0p : n;
-//                      } else &tp = 0p;
-//                      return &tp != 0p;
-//              }
-//      } // distribution
-
-
-//      // A SeqIterRev(T) is used to iterate over a Sequence(T) in tail-to-head order.
-//      struct SeqIterRev {
-//              inline ColIter;
-//              // See above for explanation.
-//              Sequence(T) * seq;                                                              // FIX ME: cannot be reference
-//      };
-
-//      static inline {
-//              void ?{}( SeqIterRev(T) & si ) with( si ) {     
-//                      ((ColIter &)si){};
-//                      seq = 0p;
-//              } // post: elts = null.
-
-//              void ?{}( SeqIterRev(T) & si, Sequence(T) & s ) with( si ) {    
-//                      ((ColIter &)si){};
-//                      seq = &s;
-//                      curr = &tail( s );
-//              } // post: elts = null.
-
-//              void ?{}( SeqIterRev(T) & si, Sequence(T) & s, T & start ) with( si ) { 
-//                      ((ColIter &)si){};
-//                      seq = &s;
-//                      curr = &start;
-//              } // post: elts = null.
-
-//              void over( SeqIterRev(T) & si, Sequence(T) & s ) with( si ) {
-//                      seq = &s;
-//                      curr = &tail( s );
-//              } // post: elts = {e in s}.
-
-//              bool ?>>?( SeqIterRev(T) & si, T && tp ) with( si ) {
-//                      if ( curr ) {
-//                              &tp = Curr( si );
-//                              T * n = pred( *seq, Curr( si ) );
-//                              curr = n == &tail( *seq ) ? 0p : n;
-//                      } else &tp = 0p;
-//                      return &tp != 0p;
-//              }
-//      } // distribution
-// } // distribution
+forall( dtype T | { T *& Back ( T * ); T *& Next ( T * ); bool listed ( T * ); } ) {
+        // SeqIter(T) is used to iterate over a Sequence(T) in head-to-tail order.
+        struct SeqIter {
+                inline ColIter;
+                // The Sequence must be passed to pred and succ to check for the end of the Sequence and return 0p. Without
+                // passing the sequence, traversing would require its length. Thus the iterator needs a pointer to the sequence
+                // to pass to succ/pred. Both stack and queue just encounter 0p since the lists are not circular.
+                Sequence(T) * seq;                                                              // FIX ME: cannot be reference
+        };
+
+        static inline {
+                void ?{}( SeqIter(T) & si ) with( si ) {
+                        ((ColIter &)si){};
+                        seq = 0p;
+                } // post: elts = null.
+
+                void ?{}( SeqIter(T) & si, Sequence(T) & s ) with( si ) {
+                        ((ColIter &)si){};
+                        seq = &s;
+                        curr = &head( s );
+                } // post: elts = null.
+
+                void ?{}( SeqIter(T) & si, Sequence(T) & s, T & start ) with( si ) {
+                        ((ColIter &)si){};
+                        seq = &s;
+                        curr = &start;
+                } // post: elts = null.
+
+                void over( SeqIter(T) & si, Sequence(T) & s ) with( si ) {
+                        seq = &s;
+                        curr = &head( s );
+                } // post: elts = {e in s}.
+
+                bool ?>>?( SeqIter(T) & si, T && tp ) with( si ) {
+                        if ( curr ) {
+                                &tp = Curr( si );
+                                T * n = succ( *seq, Curr( si ) );
+                                curr = n == &head( *seq ) ? 0p : n;
+                        } else &tp = 0p;
+                        return &tp != 0p;
+                }
+        } // distribution
+
+
+        // A SeqIterRev(T) is used to iterate over a Sequence(T) in tail-to-head order.
+        struct SeqIterRev {
+                inline ColIter;
+                // See above for explanation.
+                Sequence(T) * seq;                                                              // FIX ME: cannot be reference
+        };
+
+        static inline {
+                void ?{}( SeqIterRev(T) & si ) with( si ) {     
+                        ((ColIter &)si){};
+                        seq = 0p;
+                } // post: elts = null.
+
+                void ?{}( SeqIterRev(T) & si, Sequence(T) & s ) with( si ) {    
+                        ((ColIter &)si){};
+                        seq = &s;
+                        curr = &tail( s );
+                } // post: elts = null.
+
+                void ?{}( SeqIterRev(T) & si, Sequence(T) & s, T & start ) with( si ) { 
+                        ((ColIter &)si){};
+                        seq = &s;
+                        curr = &start;
+                } // post: elts = null.
+
+                void over( SeqIterRev(T) & si, Sequence(T) & s ) with( si ) {
+                        seq = &s;
+                        curr = &tail( s );
+                } // post: elts = {e in s}.
+
+                bool ?>>?( SeqIterRev(T) & si, T && tp ) with( si ) {
+                        if ( curr ) {
+                                &tp = Curr( si );
+                                T * n = pred( *seq, Curr( si ) );
+                                curr = n == &tail( *seq ) ? 0p : n;
+                        } else &tp = 0p;
+                        return &tp != 0p;
+                }
+        } // distribution
+} // distribution
 
 #endif