diff --git a/octa/algorithm.h b/octa/algorithm.h
index a94edd9..2d89e2f 100644
--- a/octa/algorithm.h
+++ b/octa/algorithm.h
@@ -20,10 +20,10 @@ namespace octa {
     template<typename R, typename U>
     R partition(R range, U pred) {
         R ret = range;
-        for (; !range.empty(); range.pop_first()) {
-            if (pred(range.first())) {
-                swap(range.first(), ret.first());
-                ret.pop_first();
+        for (; !range.empty(); range.pop_front()) {
+            if (pred(range.front())) {
+                swap(range.front(), ret.front());
+                ret.pop_front();
             }
         }
         return ret;
@@ -31,9 +31,9 @@ namespace octa {
 
     template<typename R, typename P>
     bool is_partitioned(R range, P pred) {
-        for (; !range.empty() && pred(range.first()); range.pop_first());
-        for (; !range.empty(); range.pop_first())
-            if (pred(range.first())) return false;
+        for (; !range.empty() && pred(range.front()); range.pop_front());
+        for (; !range.empty(); range.pop_front())
+            if (pred(range.front())) return false;
         return true;
     }
 
@@ -105,10 +105,10 @@ namespace octa {
             return;
         }
         RangeReference<R> p = range[range.size() / 2];
-        swap(p, range.last());
+        swap(p, range.back());
         R r = partition(range, __OctaUnaryCompare<decltype(p), C>{ p, compare });
         R l = range.slice(0, range.size() - r.size());
-        swap(r.first(), r.last());
+        swap(r.front(), r.back());
         __octa_introloop(l, compare, depth - 1);
         __octa_introloop(r, compare, depth - 1);
     }
@@ -152,16 +152,16 @@ namespace octa {
     template<typename R>
     inline R min_element(R range) {
         R r = range;
-        for (; !range.empty(); range.pop_first())
-            if (min(r.first(), range.first()) == range.first())
+        for (; !range.empty(); range.pop_front())
+            if (min(r.front(), range.front()) == range.front())
                 r = range;
         return r;
     }
     template<typename R, typename C>
     inline R min_element(R range, C compare) {
         R r = range;
-        for (; !range.empty(); range.pop_first())
-            if (min(r.first(), range.first(), compare) == range.first())
+        for (; !range.empty(); range.pop_front())
+            if (min(r.front(), range.front(), compare) == range.front())
                 r = range;
         return r;
     }
@@ -169,16 +169,16 @@ namespace octa {
     template<typename R>
     inline R max_element(R range) {
         R r = range;
-        for (; !range.empty(); range.pop_first())
-            if (max(r.first(), range.first()) == range.first())
+        for (; !range.empty(); range.pop_front())
+            if (max(r.front(), range.front()) == range.front())
                 r = range;
         return r;
     }
     template<typename R, typename C>
     inline R max_element(R range, C compare) {
         R r = range;
-        for (; !range.empty(); range.pop_first())
-            if (max(r.first(), range.first(), compare) == range.first())
+        for (; !range.empty(); range.pop_front())
+            if (max(r.front(), range.front(), compare) == range.front())
                 r = range;
         return r;
     }
@@ -187,21 +187,21 @@ namespace octa {
 
     template<typename T>
     inline T min(initializer_list<T> il) {
-        return min_element(each(il)).first();
+        return min_element(each(il)).front();
     }
     template<typename T, typename C>
     inline T min(initializer_list<T> il, C compare) {
-        return min_element(each(il), compare).first();
+        return min_element(each(il), compare).front();
     }
 
     template<typename T>
     inline T max(initializer_list<T> il) {
-        return max_element(each(il)).first();
+        return max_element(each(il)).front();
     }
 
     template<typename T, typename C>
     inline T max(initializer_list<T> il, C compare) {
-        return max_element(each(il), compare).first();
+        return max_element(each(il), compare).front();
     }
 
     /* clamp */
@@ -220,52 +220,52 @@ namespace octa {
 
     template<typename R, typename F>
     F for_each(R range, F func) {
-        for (; !range.empty(); range.pop_first())
-            func(range.first());
+        for (; !range.empty(); range.pop_front())
+            func(range.front());
         return move(func);
     }
 
     template<typename R, typename P>
     bool all_of(R range, P pred) {
-        for (; !range.empty(); range.pop_first())
-            if (!pred(range.first())) return false;
+        for (; !range.empty(); range.pop_front())
+            if (!pred(range.front())) return false;
         return true;
     }
 
     template<typename R, typename P>
     bool any_of(R range, P pred) {
-        for (; !range.empty(); range.pop_first())
-            if (pred(range.first())) return true;
+        for (; !range.empty(); range.pop_front())
+            if (pred(range.front())) return true;
         return false;
     }
 
     template<typename R, typename P>
     bool none_of(R range, P pred) {
-        for (; !range.empty(); range.pop_first())
-            if (pred(range.first())) return false;
+        for (; !range.empty(); range.pop_front())
+            if (pred(range.front())) return false;
         return true;
     }
 
     template<typename R, typename T>
     R find(R range, const T &v) {
-        for (; !range.empty(); range.pop_first())
-            if (range.first() == v)
+        for (; !range.empty(); range.pop_front())
+            if (range.front() == v)
                 break;
         return range;
     }
 
     template<typename R, typename P>
     R find_if(R range, P pred) {
-        for (; !range.empty(); range.pop_first())
-            if (pred(range.first()))
+        for (; !range.empty(); range.pop_front())
+            if (pred(range.front()))
                 break;
         return range;
     }
 
     template<typename R, typename P>
     R find_if_not(R range, P pred) {
-        for (; !range.empty(); range.pop_first())
-            if (!pred(range.first()))
+        for (; !range.empty(); range.pop_front())
+            if (!pred(range.front()))
                 break;
         return range;
     }
@@ -273,8 +273,8 @@ namespace octa {
     template<typename R, typename T>
     RangeSize<R> count(R range, const T &v) {
         RangeSize<R> ret = 0;
-        for (; !range.empty(); range.pop_first())
-            if (range.first() == v)
+        for (; !range.empty(); range.pop_front())
+            if (range.front() == v)
                 ++ret;
         return ret;
     }
@@ -282,8 +282,8 @@ namespace octa {
     template<typename R, typename P>
     RangeSize<R> count_if(R range, P pred) {
         RangeSize<R> ret = 0;
-        for (; !range.empty(); range.pop_first())
-            if (pred(range.first()))
+        for (; !range.empty(); range.pop_front())
+            if (pred(range.front()))
                 ++ret;
         return ret;
     }
@@ -291,18 +291,18 @@ namespace octa {
     template<typename R, typename P>
     RangeSize<R> count_if_not(R range, P pred) {
         RangeSize<R> ret = 0;
-        for (; !range.empty(); range.pop_first())
-            if (!pred(range.first()))
+        for (; !range.empty(); range.pop_front())
+            if (!pred(range.front()))
                 ++ret;
         return ret;
     }
 
     template<typename R>
     bool equal(R range1, R range2) {
-        for (; !range1.empty(); range1.pop_first()) {
-            if (range2.empty() || (range1.first() != range2.first()))
+        for (; !range1.empty(); range1.pop_front()) {
+            if (range2.empty() || (range1.front() != range2.front()))
                 return false;
-            range2.pop_first();
+            range2.pop_front();
         }
         return range2.empty();
     }
@@ -311,103 +311,103 @@ namespace octa {
 
     template<typename R1, typename R2>
     R2 copy(R1 irange, R2 orange) {
-        for (; !irange.empty(); irange.pop_first())
-            orange.put(irange.first());
+        for (; !irange.empty(); irange.pop_front())
+            orange.put(irange.front());
         return orange;
     }
 
     template<typename R1, typename R2, typename P>
     R2 copy_if(R1 irange, R2 orange, P pred) {
-        for (; !irange.empty(); irange.pop_first())
-            if (pred(irange.first()))
-                orange.put(irange.first());
+        for (; !irange.empty(); irange.pop_front())
+            if (pred(irange.front()))
+                orange.put(irange.front());
         return orange;
     }
 
     template<typename R1, typename R2, typename P>
     R2 copy_if_not(R1 irange, R2 orange, P pred) {
-        for (; !irange.empty(); irange.pop_first())
-            if (!pred(irange.first()))
-                orange.put(irange.first());
+        for (; !irange.empty(); irange.pop_front())
+            if (!pred(irange.front()))
+                orange.put(irange.front());
         return orange;
     }
 
     template<typename R1, typename R2>
     R2 move(R1 irange, R2 orange) {
-        for (; !irange.empty(); irange.pop_first())
-            orange.put(move(irange.first()));
+        for (; !irange.empty(); irange.pop_front())
+            orange.put(move(irange.front()));
         return orange;
     }
 
     template<typename R>
     void reverse(R range) {
         while (!range.empty()) {
-            swap(range.first(), range.last());
-            range.pop_first();
-            range.pop_last();
+            swap(range.front(), range.back());
+            range.pop_front();
+            range.pop_back();
         }
     }
 
     template<typename R1, typename R2>
     R2 reverse_copy(R1 irange, R2 orange) {
-        for (; !irange.empty(); irange.pop_last())
-            orange.put(irange.last());
+        for (; !irange.empty(); irange.pop_back())
+            orange.put(irange.back());
         return orange;
     }
 
     template<typename R, typename T>
     void fill(R range, const T &v) {
-        for (; !range.empty(); range.pop_first())
-            range.first() = v;
+        for (; !range.empty(); range.pop_front())
+            range.front() = v;
     }
 
     template<typename R, typename F>
     void generate(R range, F gen) {
-        for (; !range.empty(); range.pop_first())
-            range.first() = gen();
+        for (; !range.empty(); range.pop_front())
+            range.front() = gen();
     }
 
     template<typename R1, typename R2>
     Pair<R1, R2> swap_ranges(R1 range1, R2 range2) {
         while (!range1.empty() && !range2.empty()) {
-            swap(range1.first(), range2.first());
-            range1.pop_first();
-            range2.pop_first();
+            swap(range1.front(), range2.front());
+            range1.pop_front();
+            range2.pop_front();
         }
         return Pair<R1, R2>(range1, range2);
     }
 
     template<typename R, typename T>
     void iota(R range, T value) {
-        for (; !range.empty(); range.pop_first())
-            range.first() = value++;
+        for (; !range.empty(); range.pop_front())
+            range.front() = value++;
     }
 
     template<typename R, typename T>
     T foldl(R range, T init) {
-        for (; !range.empty(); range.pop_first())
-            init = init + range.first();
+        for (; !range.empty(); range.pop_front())
+            init = init + range.front();
         return init;
     }
 
     template<typename R, typename T, typename F>
     T foldl(R range, T init, F func) {
-        for (; !range.empty(); range.pop_first())
-            init = func(init, range.first());
+        for (; !range.empty(); range.pop_front())
+            init = func(init, range.front());
         return init;
     }
 
     template<typename R, typename T>
     T foldr(R range, T init) {
-        for (; !range.empty(); range.pop_last())
-            init = init + range.last();
+        for (; !range.empty(); range.pop_back())
+            init = init + range.back();
         return init;
     }
 
     template<typename R, typename T, typename F>
     T foldr(R range, T init, F func) {
-        for (; !range.empty(); range.pop_last())
-            init = func(init, range.last());
+        for (; !range.empty(); range.pop_back())
+            init = func(init, range.back());
         return init;
     }
 
@@ -440,34 +440,34 @@ namespace octa {
         bool empty() const { return p_range.empty(); }
         RangeSize<T> size() const { return p_range.size(); }
 
-        bool equals_first(const MapRange &range) const {
-            return p_range.equals_first(range.p_range);
+        bool equals_front(const MapRange &range) const {
+            return p_range.equals_front(range.p_range);
         }
-        bool equals_last(const MapRange &range) const {
-            return p_range.equals_first(range.p_range);
+        bool equals_back(const MapRange &range) const {
+            return p_range.equals_front(range.p_range);
         }
 
-        RangeDifference<T> distance_first(const MapRange &range) const {
-            return p_range.distance_first(range.p_range);
+        RangeDifference<T> distance_front(const MapRange &range) const {
+            return p_range.distance_front(range.p_range);
         }
-        RangeDifference<T> distance_last(const MapRange &range) const {
-            return p_range.distance_last(range.p_range);
+        RangeDifference<T> distance_back(const MapRange &range) const {
+            return p_range.distance_back(range.p_range);
         }
 
-        bool pop_first() { return p_range.pop_first(); }
-        bool pop_last() { return p_range.pop_last(); }
+        bool pop_front() { return p_range.pop_front(); }
+        bool pop_back() { return p_range.pop_back(); }
 
-        bool push_first() { return p_range.pop_first(); }
-        bool push_last() { return p_range.push_last(); }
+        bool push_front() { return p_range.pop_front(); }
+        bool push_back() { return p_range.push_back(); }
 
-        RangeSize<T> pop_first_n(RangeSize<T> n) { p_range.pop_first_n(n); }
-        RangeSize<T> pop_last_n(RangeSize<T> n) { p_range.pop_last_n(n); }
+        RangeSize<T> pop_front_n(RangeSize<T> n) { p_range.pop_front_n(n); }
+        RangeSize<T> pop_back_n(RangeSize<T> n) { p_range.pop_back_n(n); }
 
-        RangeSize<T> push_first_n(RangeSize<T> n) { return p_range.push_first_n(n); }
-        RangeSize<T> push_last_n(RangeSize<T> n) { return p_range.push_last_n(n); }
+        RangeSize<T> push_front_n(RangeSize<T> n) { return p_range.push_front_n(n); }
+        RangeSize<T> push_back_n(RangeSize<T> n) { return p_range.push_back_n(n); }
 
-        R first() const { return p_func(p_range.first()); }
-        R last() const { return p_func(p_range.last()); }
+        R front() const { return p_func(p_range.front()); }
+        R back() const { return p_func(p_range.back()); }
 
         R operator[](RangeSize<T> idx) const {
             return p_func(p_range[idx]);
@@ -496,7 +496,7 @@ namespace octa {
         Function<bool(RangeReference<T>)> p_pred;
 
         void advance_valid() {
-            while (!p_range.empty() && !p_pred(first())) p_range.pop_first();
+            while (!p_range.empty() && !p_pred(front())) p_range.pop_front();
         }
 
     public:
@@ -531,26 +531,26 @@ namespace octa {
 
         bool empty() const { return p_range.empty(); }
 
-        bool equals_first(const FilterRange &range) const {
-            return p_range.equals_first(range.p_range);
+        bool equals_front(const FilterRange &range) const {
+            return p_range.equals_front(range.p_range);
         }
 
-        bool pop_first() {
-            bool ret = p_range.pop_first();
+        bool pop_front() {
+            bool ret = p_range.pop_front();
             advance_valid();
             return ret;
         }
-        bool push_first() {
+        bool push_front() {
             T tmp = p_range;
-            if (!tmp.push_first()) return false;
-            while (!pred(tmp.first()))
-                if (!tmp.push_first())
+            if (!tmp.push_front()) return false;
+            while (!pred(tmp.front()))
+                if (!tmp.push_front())
                     return false;
             p_range = tmp;
             return true;
         }
 
-        RangeReference<T> first() const { return p_range.first(); }
+        RangeReference<T> front() const { return p_range.front(); }
     };
 
     template<typename R, typename P>
diff --git a/octa/array.h b/octa/array.h
index 500a3ef..9b5ae45 100644
--- a/octa/array.h
+++ b/octa/array.h
@@ -31,11 +31,11 @@ namespace octa {
         T &at(size_t i) { return p_buf[i]; }
         const T &at(size_t i) const { return p_buf[i]; }
 
-        T &first() { return p_buf[0]; }
-        const T &first() const { return p_buf[0]; }
+        T &front() { return p_buf[0]; }
+        const T &front() const { return p_buf[0]; }
 
-        T &last() { return p_buf[(N > 0) ? (N - 1) : 0]; }
-        const T &last() const { return p_buf[(N > 0) ? (N - 1) : 0]; }
+        T &back() { return p_buf[(N > 0) ? (N - 1) : 0]; }
+        const T &back() const { return p_buf[(N > 0) ? (N - 1) : 0]; }
 
         size_t size() const { return N; }
 
diff --git a/octa/range.h b/octa/range.h
index 09b1e4b..8140cf3 100644
--- a/octa/range.h
+++ b/octa/range.h
@@ -121,11 +121,11 @@ namespace octa {
         __OctaRangeIterator(): p_range() {}
         explicit __OctaRangeIterator(const T &range): p_range(range) {}
         __OctaRangeIterator &operator++() {
-            p_range.pop_first();
+            p_range.pop_front();
             return *this;
         }
         RangeReference<T> operator*() const {
-            return p_range.first();
+            return p_range.front();
         }
         bool operator!=(__OctaRangeIterator) const { return !p_range.empty(); }
     private:
@@ -158,26 +158,26 @@ namespace octa {
 
         T range() const { return p_range; }
 
-        bool next() { return p_range.pop_first(); }
-        bool prev() { return p_range.push_first(); }
+        bool next() { return p_range.pop_front(); }
+        bool prev() { return p_range.push_front(); }
 
         RangeSize<T> next_n(RangeSize<T> n) {
-            return p_range.pop_first_n(n);
+            return p_range.pop_front_n(n);
         }
         RangeSize<T> prev_n(RangeSize<T> n) {
-            return p_range.push_first_n(n);
+            return p_range.push_front_n(n);
         }
 
         RangeReference<T> get() const {
-            return p_range.first();
+            return p_range.front();
         }
 
         RangeDifference<T> distance(const RangeHalf &half) const {
-            return p_range.distance_first(half.p_range);
+            return p_range.distance_front(half.p_range);
         }
 
         bool equals(const RangeHalf &half) const {
-            return p_range.equals_first(half.p_range);
+            return p_range.equals_front(half.p_range);
         }
 
         bool operator==(const RangeHalf &half) const {
@@ -248,30 +248,30 @@ namespace octa {
     }
 
     template<typename R>
-    RangeSize<R> __octa_pop_first_n(R &range, RangeSize<R> n) {
+    RangeSize<R> __octa_pop_front_n(R &range, RangeSize<R> n) {
         for (RangeSize<R> i = 0; i < n; ++i)
-            if (!range.pop_first()) return i;
+            if (!range.pop_front()) return i;
         return n;
     }
 
     template<typename R>
-    RangeSize<R> __octa_pop_last_n(R &range, RangeSize<R> n) {
+    RangeSize<R> __octa_pop_back_n(R &range, RangeSize<R> n) {
         for (RangeSize<R> i = 0; i < n; ++i)
-            if (!range.pop_last()) return i;
+            if (!range.pop_back()) return i;
         return n;
     }
 
     template<typename R>
-    RangeSize<R> __octa_push_first_n(R &range, RangeSize<R> n) {
+    RangeSize<R> __octa_push_front_n(R &range, RangeSize<R> n) {
         for (RangeSize<R> i = 0; i < n; ++i)
-            if (!range.push_first()) return i;
+            if (!range.push_front()) return i;
         return n;
     }
 
     template<typename R>
-    RangeSize<R> __octa_push_last_n(R &range, RangeSize<R> n) {
+    RangeSize<R> __octa_push_back_n(R &range, RangeSize<R> n) {
         for (RangeSize<R> i = 0; i < n; ++i)
-            if (!range.push_last()) return i;
+            if (!range.push_back()) return i;
         return n;
     }
 
@@ -291,20 +291,20 @@ namespace octa {
             return __OctaRangeIterator<B>();
         }
 
-        SizeType pop_first_n(SizeType n) {
-            return __octa_pop_first_n<B>(*((B *)this), n);
+        SizeType pop_front_n(SizeType n) {
+            return __octa_pop_front_n<B>(*((B *)this), n);
         }
 
-        SizeType pop_last_n(SizeType n) {
-            return __octa_pop_last_n<B>(*((B *)this), n);
+        SizeType pop_back_n(SizeType n) {
+            return __octa_pop_back_n<B>(*((B *)this), n);
         }
 
-        SizeType push_first_n(SizeType n) {
-            return __octa_push_first_n<B>(*((B *)this), n);
+        SizeType push_front_n(SizeType n) {
+            return __octa_push_front_n<B>(*((B *)this), n);
         }
 
-        SizeType push_last_n(SizeType n) {
-            return __octa_push_last_n<B>(*((B *)this), n);
+        SizeType push_back_n(SizeType n) {
+            return __octa_push_back_n<B>(*((B *)this), n);
         }
 
         B each() const {
@@ -366,34 +366,34 @@ namespace octa {
         bool empty() const { return p_range.empty(); }
         r_size size() const { return p_range.size(); }
 
-        bool equals_first(const ReverseRange &range) const {
-        return p_range.equals_last(range.p_range);
+        bool equals_front(const ReverseRange &range) const {
+        return p_range.equals_back(range.p_range);
         }
-        bool equals_last(const ReverseRange &range) const {
-            return p_range.equals_first(range.p_range);
+        bool equals_back(const ReverseRange &range) const {
+            return p_range.equals_front(range.p_range);
         }
 
-        RangeDifference<T> distance_first(const ReverseRange &range) const {
-            return -p_range.distance_last(range.p_range);
+        RangeDifference<T> distance_front(const ReverseRange &range) const {
+            return -p_range.distance_back(range.p_range);
         }
-        RangeDifference<T> distance_last(const ReverseRange &range) const {
-            return -p_range.distance_first(range.p_range);
+        RangeDifference<T> distance_back(const ReverseRange &range) const {
+            return -p_range.distance_front(range.p_range);
         }
 
-        bool pop_first() { return p_range.pop_last(); }
-        bool pop_last() { return p_range.pop_first(); }
+        bool pop_front() { return p_range.pop_back(); }
+        bool pop_back() { return p_range.pop_front(); }
 
-        bool push_first() { return p_range.push_last(); }
-        bool push_last() { return p_range.push_first(); }
+        bool push_front() { return p_range.push_back(); }
+        bool push_back() { return p_range.push_front(); }
 
-        r_size pop_first_n(r_size n) { return p_range.pop_first_n(n); }
-        r_size pop_last_n(r_size n) { return p_range.pop_last_n(n); }
+        r_size pop_front_n(r_size n) { return p_range.pop_front_n(n); }
+        r_size pop_back_n(r_size n) { return p_range.pop_back_n(n); }
 
-        r_size push_first_n(r_size n) { return p_range.push_first_n(n); }
-        r_size push_last_n(r_size n) { return p_range.push_last_n(n); }
+        r_size push_front_n(r_size n) { return p_range.push_front_n(n); }
+        r_size push_back_n(r_size n) { return p_range.push_back_n(n); }
 
-        r_ref first() const { return p_range.last(); }
-        r_ref last() const { return p_range.first(); }
+        r_ref front() const { return p_range.back(); }
+        r_ref back() const { return p_range.front(); }
 
         r_ref operator[](r_size i) const { return p_range[size() - i - 1]; }
 
@@ -449,34 +449,34 @@ namespace octa {
         bool empty() const { return p_range.empty(); }
         r_size size() const { return p_range.size(); }
 
-        bool equals_first(const MoveRange &range)  const {
-            return p_range.equals_first(range.p_range);
+        bool equals_front(const MoveRange &range)  const {
+            return p_range.equals_front(range.p_range);
         }
-        bool equals_last(const MoveRange &range) const {
-            return p_range.equals_last(range.p_range);
+        bool equals_back(const MoveRange &range) const {
+            return p_range.equals_back(range.p_range);
         }
 
-        RangeDifference<T> distance_first(const MoveRange &range) const {
-            return p_range.distance_first(range.p_range);
+        RangeDifference<T> distance_front(const MoveRange &range) const {
+            return p_range.distance_front(range.p_range);
         }
-        RangeDifference<T> distance_last(const MoveRange &range) const {
-            return p_range.distance_last(range.p_range);
+        RangeDifference<T> distance_back(const MoveRange &range) const {
+            return p_range.distance_back(range.p_range);
         }
 
-        bool pop_first() { return p_range.pop_first(); }
-        bool pop_last() { return p_range.pop_last(); }
+        bool pop_front() { return p_range.pop_front(); }
+        bool pop_back() { return p_range.pop_back(); }
 
-        bool push_first() { return p_range.push_first(); }
-        bool push_last() { return p_range.push_last(); }
+        bool push_front() { return p_range.push_front(); }
+        bool push_back() { return p_range.push_back(); }
 
-        r_size pop_first_n(r_size n) { return p_range.pop_first_n(n); }
-        r_size pop_last_n(r_size n) { return p_range.pop_last_n(n); }
+        r_size pop_front_n(r_size n) { return p_range.pop_front_n(n); }
+        r_size pop_back_n(r_size n) { return p_range.pop_back_n(n); }
 
-        r_size push_first_n(r_size n) { return p_range.push_first_n(n); }
-        r_size push_last_n(r_size n) { return p_range.push_last_n(n); }
+        r_size push_front_n(r_size n) { return p_range.push_front_n(n); }
+        r_size push_back_n(r_size n) { return p_range.push_back_n(n); }
 
-        r_ref first() const { return move(p_range.first()); }
-        r_ref last() const { return move(p_range.last()); }
+        r_ref front() const { return move(p_range.front()); }
+        r_ref back() const { return move(p_range.back()); }
 
         r_ref operator[](r_size i) const { return move(p_range[i]); }
 
@@ -504,13 +504,13 @@ namespace octa {
 
         bool empty() const { return p_a * p_step >= p_b * p_step; }
 
-        bool equals_first(const NumberRange &range) const {
+        bool equals_front(const NumberRange &range) const {
             return p_a == range.p_a;
         }
 
-        bool pop_first() { p_a += p_step; return true; }
-        bool push_first() { p_a -= p_step; return true; }
-        T first() const { return p_a; }
+        bool pop_front() { p_a += p_step; return true; }
+        bool push_front() { p_a -= p_step; return true; }
+        T front() const { return p_a; }
 
     private:
         T p_a, p_b, p_step;
@@ -543,16 +543,16 @@ namespace octa {
         /* satisfy InputRange / ForwardRange */
         bool empty() const { return p_beg == p_end; }
 
-        bool pop_first() {
+        bool pop_front() {
             if (p_beg == p_end) return false;
             ++p_beg;
             return true;
         }
-        bool push_first() {
+        bool push_front() {
             --p_beg; return true;
         }
 
-        size_t pop_first_n(size_t n) {
+        size_t pop_front_n(size_t n) {
             T *obeg = p_beg;
             size_t olen = p_end - p_beg;
             p_beg += n;
@@ -563,31 +563,31 @@ namespace octa {
             return n;
         }
 
-        size_t push_first_n(size_t n) {
+        size_t push_front_n(size_t n) {
             p_beg -= n; return true;
         }
 
-        T &first() const { return *p_beg; }
+        T &front() const { return *p_beg; }
 
-        bool equals_first(const PointerRange &range)  const {
+        bool equals_front(const PointerRange &range)  const {
             return p_beg == range.p_beg;
         }
 
-        ptrdiff_t distance_first(const PointerRange &range) const {
+        ptrdiff_t distance_front(const PointerRange &range) const {
             return range.p_beg;
         }
 
         /* satisfy BidirectionalRange */
-        bool pop_last() {
+        bool pop_back() {
             if (p_end == p_beg) return false;
             --p_end;
             return true;
         }
-        bool push_last() {
+        bool push_back() {
             ++p_end; return true;
         }
 
-        size_t pop_last_n(size_t n) {
+        size_t pop_back_n(size_t n) {
             T *oend = p_end;
             size_t olen = p_end - p_beg;
             p_end -= n;
@@ -598,17 +598,17 @@ namespace octa {
             return n;
         }
 
-        size_t push_last_n(size_t n) {
+        size_t push_back_n(size_t n) {
             p_end += n; return true;
         }
 
-        T &last() const { return *(p_end - 1); }
+        T &back() const { return *(p_end - 1); }
 
-        bool equals_last(const PointerRange &range) const {
+        bool equals_back(const PointerRange &range) const {
             return p_end == range.p_end;
         }
 
-        ptrdiff_t distance_last(const PointerRange &range) const {
+        ptrdiff_t distance_back(const PointerRange &range) const {
             return range.p_end;
         }
 
@@ -686,26 +686,26 @@ namespace octa {
 
         bool empty() const { return p_range.empty(); }
 
-        bool equals_first(const EnumeratedRange &range) const {
-            return p_range.equals_first(range.p_range);
+        bool equals_front(const EnumeratedRange &range) const {
+            return p_range.equals_front(range.p_range);
         }
 
-        bool pop_first() {
-            if (p_range.pop_first()) {
+        bool pop_front() {
+            if (p_range.pop_front()) {
                 ++p_index;
                 return true;
             }
             return false;
         }
 
-        r_size pop_first_n(r_size n) {
-            r_size ret = p_range.pop_first_n(n);
+        r_size pop_front_n(r_size n) {
+            r_size ret = p_range.pop_front_n(n);
             p_index += ret;
             return ret;
         }
 
-        EnumeratedValue<r_ref, r_size> first() const {
-            return EnumeratedValue<r_ref, r_size> { p_index, p_range.first() };
+        EnumeratedValue<r_ref, r_size> front() const {
+            return EnumeratedValue<r_ref, r_size> { p_index, p_range.front() };
         }
     };
 
@@ -740,40 +740,40 @@ namespace octa {
 
         bool empty() const { return (p_remaining <= 0) || p_range.empty(); }
 
-        bool pop_first() {
-            if (p_range.pop_first()) {
+        bool pop_front() {
+            if (p_range.pop_front()) {
                 --p_remaining;
                 return true;
             }
             return false;
         }
-        bool push_first() {
-            if (p_range.push_first()) {
+        bool push_front() {
+            if (p_range.push_front()) {
                 ++p_remaining;
                 return true;
             }
             return false;
         }
 
-        RangeSize<T> pop_first_n(RangeSize<T> n) {
-            RangeSize<T> ret = p_range.pop_first_n(n);
+        RangeSize<T> pop_front_n(RangeSize<T> n) {
+            RangeSize<T> ret = p_range.pop_front_n(n);
             p_remaining -= ret;
             return ret;
         }
-        RangeSize<T> push_first_n(RangeSize<T> n) {
-            RangeSize<T> ret = p_range.push_first_n(n);
+        RangeSize<T> push_front_n(RangeSize<T> n) {
+            RangeSize<T> ret = p_range.push_front_n(n);
             p_remaining += ret;
             return ret;
         }
 
-        RangeReference<T> first() const { return p_range.first(); }
+        RangeReference<T> front() const { return p_range.front(); }
 
-        bool equals_first(const TakeRange &range) const {
-            return p_range.equals_first(range.p_range);
+        bool equals_front(const TakeRange &range) const {
+            return p_range.equals_front(range.p_range);
         }
 
-        RangeDifference<T> distance_first(const TakeRange &range) const {
-            return p_range.distance_first(range.p_range);
+        RangeDifference<T> distance_front(const TakeRange &range) const {
+            return p_range.distance_front(range.p_range);
         }
     };
 
@@ -808,34 +808,34 @@ namespace octa {
 
         bool empty() const { return p_range.empty(); }
 
-        bool equals_first(const ChunksRange &range) const {
-            return p_range.equals_first(range.p_range);
+        bool equals_front(const ChunksRange &range) const {
+            return p_range.equals_front(range.p_range);
         }
 
-        bool pop_first() { return p_range.pop_first_n(p_chunksize) > 0; }
-        bool push_first() {
+        bool pop_front() { return p_range.pop_front_n(p_chunksize) > 0; }
+        bool push_front() {
             T tmp = p_range;
-            RangeSize<T> an = tmp.push_first_n(p_chunksize);
+            RangeSize<T> an = tmp.push_front_n(p_chunksize);
             if (an != p_chunksize) return false;
             p_range = tmp;
             return true;
         }
-        RangeSize<T> pop_first_n(RangeSize<T> n) {
-            return p_range.pop_first_n(p_chunksize * n) / p_chunksize;
+        RangeSize<T> pop_front_n(RangeSize<T> n) {
+            return p_range.pop_front_n(p_chunksize * n) / p_chunksize;
         }
-        RangeSize<T> push_first_n(RangeSize<T> n) {
+        RangeSize<T> push_front_n(RangeSize<T> n) {
             T tmp = p_range;
-            RangeSize<T> an = tmp.push_first_n(p_chunksize * n);
+            RangeSize<T> an = tmp.push_front_n(p_chunksize * n);
             RangeSize<T> pn = an / p_chunksize;
             if (!pn) return 0;
             if (pn == n) {
                 p_range = tmp;
                 return pn;
             }
-            return p_range.push_first_n(p_chunksize * an) / p_chunksize;
+            return p_range.push_front_n(p_chunksize * an) / p_chunksize;
         }
 
-        TakeRange<T> first() const { return take(p_range, p_chunksize); }
+        TakeRange<T> front() const { return take(p_range, p_chunksize); }
     };
 
     template<typename T>
@@ -892,35 +892,35 @@ namespace octa {
 
         bool empty() const { return p_beg == p_end; }
 
-        bool pop_first() {
+        bool pop_front() {
             if (empty()) return false;
             return p_beg.next();
         }
-        bool push_first() {
+        bool push_front() {
             return p_beg.prev();
         }
-        bool pop_last() {
+        bool pop_back() {
             if (empty()) return false;
             return p_end.prev();
         }
-        bool push_last() {
+        bool push_back() {
             return p_end.next();
         }
 
-        RangeReference<T> first() const { return *p_beg; }
-        RangeReference<T> last() const { return *(p_end - 1); }
+        RangeReference<T> front() const { return *p_beg; }
+        RangeReference<T> back() const { return *(p_end - 1); }
 
-        bool equals_first(const HalfRange &range) const {
+        bool equals_front(const HalfRange &range) const {
             return p_beg == range.p_beg;
         }
-        bool equals_last(const HalfRange &range) const {
+        bool equals_back(const HalfRange &range) const {
             return p_end == range.p_end;
         }
 
-        RangeDifference<T> distance_first(const HalfRange &range) const {
+        RangeDifference<T> distance_front(const HalfRange &range) const {
             return range.p_beg - p_beg;
         }
-        RangeDifference<T> distance_last(const HalfRange &range) const {
+        RangeDifference<T> distance_back(const HalfRange &range) const {
             return range.p_end - p_end;
         }
 
diff --git a/octa/string.h b/octa/string.h
index 7c52e9c..ccaff08 100644
--- a/octa/string.h
+++ b/octa/string.h
@@ -23,7 +23,7 @@ namespace octa {
         Vector<T> p_buf;
 
         void terminate() {
-            if (p_buf.empty() || (p_buf.last() != '\0')) p_buf.push('\0');
+            if (p_buf.empty() || (p_buf.back() != '\0')) p_buf.push('\0');
         }
 
     public:
@@ -86,11 +86,11 @@ namespace octa {
         T &at(size_t i) { return p_buf[i]; }
         const T &at(size_t i) const { return p_buf[i]; }
 
-        T &first() { return p_buf[0]; }
-        const T &first() const { return p_buf[0]; };
+        T &front() { return p_buf[0]; }
+        const T &front() const { return p_buf[0]; };
 
-        T &last() { return p_buf[size() - 1]; }
-        const T &last() const { return p_buf[size() - 1]; }
+        T &back() { return p_buf[size() - 1]; }
+        const T &back() const { return p_buf[size() - 1]; }
 
         T *data() { return p_buf.data(); }
         const T *data() const { return p_buf.data(); }
@@ -106,7 +106,7 @@ namespace octa {
         bool empty() const { return (size() == 0); }
 
         void push(T v) {
-            p_buf.last() = v;
+            p_buf.back() = v;
             p_buf.push('\0');
         }
 
@@ -186,8 +186,8 @@ namespace octa {
         auto range = each(v);
         if (range.empty()) return move(ret);
         for (;;) {
-            ret += func(range.first());
-            range.pop_first();
+            ret += func(range.front());
+            range.pop_front();
             if (range.empty()) break;
             ret += sep;
         }
@@ -200,8 +200,8 @@ namespace octa {
         auto range = each(v);
         if (range.empty()) return move(ret);
         for (;;) {
-            ret += range.first();
-            range.pop_first();
+            ret += range.front();
+            range.pop_front();
             if (range.empty()) break;
             ret += sep;
         }
diff --git a/octa/vector.h b/octa/vector.h
index 5b9de80..71dd27b 100644
--- a/octa/vector.h
+++ b/octa/vector.h
@@ -37,8 +37,8 @@ namespace octa {
             RangeSize<R> len = range.size();
             reserve(len);
             p_len = len;
-            for (size_t i = 0; !range.empty(); range.pop_first()) {
-                new (&p_buf[i]) T(range.first());
+            for (size_t i = 0; !range.empty(); range.pop_front()) {
+                new (&p_buf[i]) T(range.front());
                 ++i;
             }
         }
@@ -48,9 +48,9 @@ namespace octa {
             ::value, bool
         > = true) {
             size_t i = 0;
-            for (; !range.empty(); range.pop_first()) {
+            for (; !range.empty(); range.pop_front()) {
                 reserve(i + 1);
-                new (&p_buf[i]) T(range.first());
+                new (&p_buf[i]) T(range.front());
                 ++i;
                 p_len = i;
             }
@@ -236,11 +236,11 @@ namespace octa {
             }
         }
 
-        T &first() { return p_buf[0]; }
-        const T &first() const { return p_buf[0]; };
+        T &front() { return p_buf[0]; }
+        const T &front() const { return p_buf[0]; };
 
-        T &last() { return p_buf[p_len - 1]; }
-        const T &last() const { return p_buf[p_len - 1]; }
+        T &back() { return p_buf[p_len - 1]; }
+        const T &back() const { return p_buf[p_len - 1]; }
 
         T *data() { return p_buf; }
         const T *data() const { return p_buf; }
@@ -288,8 +288,8 @@ namespace octa {
             size_t len = range.size();
             insert_base(idx, len);
             for (size_t i = 0; i < len; ++i) {
-                p_buf[idx + i] = range.first();
-                range.pop_first();
+                p_buf[idx + i] = range.front();
+                range.pop_front();
             }
             return &p_buf[idx];
         }
diff --git a/tests/array.cpp b/tests/array.cpp
index d1b99cf..75a0470 100644
--- a/tests/array.cpp
+++ b/tests/array.cpp
@@ -8,8 +8,8 @@ using namespace octa;
 int main() {
     Array<int, 5> x = { 2, 4, 8, 16, 32 };
 
-    assert(x.first() == 2);
-    assert(x.last() == 32);
+    assert(x.front() == 2);
+    assert(x.back() == 32);
 
     assert(x[0] == 2);
     assert(x[2] == 8);
@@ -28,14 +28,14 @@ int main() {
     assert(x.data()[0] == x[0]);
 
     auto r = x.each();
-    assert(r.first() == 2);
-    assert(r.last() == 32);
+    assert(r.front() == 2);
+    assert(r.back() == 32);
 
     Array<int, 5> z;
     x.swap(z);
 
-    assert(z.first() == 2);
-    assert(z.last() == 32);
+    assert(z.front() == 2);
+    assert(z.back() == 32);
 
     assert(z.size() == 5);
 
diff --git a/tests/vector.cpp b/tests/vector.cpp
index 752a915..fa7c9f7 100644
--- a/tests/vector.cpp
+++ b/tests/vector.cpp
@@ -8,8 +8,8 @@ using namespace octa;
 int main() {
     Vector<int> x = { 5, 10, 15, 20 };
 
-    assert(x.first() == 5);
-    assert(x.last() == 20);
+    assert(x.front() == 5);
+    assert(x.back() == 20);
 
     assert(x[0] == 5);
     assert(x[2] == 15);
@@ -24,13 +24,13 @@ int main() {
     Vector<int> y(5, 10);
 
     assert(y.size() == 5);
-    assert(y.first() == 10);
-    assert(y.last() == 10);
+    assert(y.front() == 10);
+    assert(y.back() == 10);
 
     Vector<int> z(x);
 
-    assert(x.first() == z.first());
-    assert(x.last() == z.last());
+    assert(x.front() == z.front());
+    assert(x.back() == z.back());
 
     z.clear();
 
@@ -42,19 +42,19 @@ int main() {
 
     assert(z.size() == 5);
     assert(y.size() == 0);
-    assert(z.first() == 10);
-    assert(z.last() == 10);
+    assert(z.front() == 10);
+    assert(z.back() == 10);
 
     z.resize(150, 5);
     assert(z.size() == 150);
-    assert(z.first() == 10);
-    assert(z.last() == 5);
+    assert(z.front() == 10);
+    assert(z.back() == 5);
 
     assert(z.push(30) == 30);
-    assert(z.last() == 30);
+    assert(z.back() == 30);
 
     assert(z.emplace_back(20) == 20);
-    assert(z.last() == 20);
+    assert(z.back() == 20);
 
     z.clear();
     z.resize(10, 5);
@@ -70,20 +70,20 @@ int main() {
     assert(z.size() == 11);
 
     auto r = z.each();
-    assert(r.first() == 5);
-    assert(r.last() == 5);
+    assert(r.front() == 5);
+    assert(r.back() == 5);
     assert(r[2] == 4);
 
     auto r2 = each(z);
-    assert(r.first() == r2.first());
+    assert(r.front() == r2.front());
 
     Vector<int> w;
     w.swap(z);
 
     assert(z.size() == 0);
     assert(w.size() != 0);
-    assert(w.first() == 5);
-    assert(w.last() == 5);
+    assert(w.front() == 5);
+    assert(w.back() == 5);
 
     assert(!strcmp(to_string(w).data(), "{5, 5, 4, 5, 5, 5, 5, 5, 5, 5, 5}"));