add field projection

Author: 9il

source/mir/ndslice/iterator.d

@@ -13,6 +13,7 @@ $(T2 FlattenedIterator, $(SUBREF topology, flattened))
 $(T2 IndexIterator, $(SUBREF topology, indexed))
 $(T2 IotaIterator, $(SUBREF topology, iota))
 $(T2 MapIterator, $(SUBREF topology, map))
+$(T2 MemberIterator, $(SUBREF topology, member))
 $(T2 RetroIterator, $(SUBREF topology, retro))
 $(T2 SliceIterator, $(SUBREF topology, map) in composition with $(LREF MapIterator) for packed slices.)
 $(T2 SlideIterator, $(SUBREF topology, diff), $(SUBREF topology, pairwise), and $(SUBREF topology, slide).)
@@ -864,6 +865,58 @@ auto mapIterator(alias fun, Iterator)(Iterator iterator)
     assert(y == result);
 }
 
+/++
+`MemberIterator` is used by $(SUBREF topology, member).
++/
+struct MemberIterator(Iterator, string member)
+{
+@optmath:
+    ///
+    Iterator _iterator;
+
+    ///
+    auto lightConst()() const @property
+    {
+        return MemberIterator!(LightConstOf!Iterator, member)(.lightConst(_iterator));
+    }
+
+    ///
+    auto lightImmutable()() immutable @property
+    {
+        return MemberIterator!(LightImmutableOf!Iterator, member)(.lightImmutable(_iterator));
+    }
+
+    auto ref opUnary(string op : "*")()
+    {
+        return __traits(getMember, *_iterator, member);
+    }
+
+    auto ref opIndex()(ptrdiff_t index)
+    {
+        return __traits(getMember, _iterator[index], member);
+    }
+
+    static if (!__traits(compiles, &opIndex(ptrdiff_t.init)))
+    {
+        auto ref opIndexAssign(T)(auto ref T value, ptrdiff_t index)
+        {
+            return __traits(getMember, _iterator[index], member) = value;
+        }
+
+        auto ref opIndexUnary(string op)(ptrdiff_t index)
+        {
+            return mixin(op ~ "__traits(getMember, _iterator[index], member)");
+        }
+
+        auto ref opIndexOpAssign(string op, T)(T value, ptrdiff_t index)
+        {
+            return mixin("__traits(getMember, _iterator[index], member)" ~ op ~ "= value");
+        }
+    }
+
+    mixin(std_ops);
+}
+
 /++
 `BytegroupIterator` is used by $(SUBREF topology, Bytegroup) and $(SUBREF topology, bytegroup).
 +/

source/mir/ndslice/package.d

@@ -103,13 +103,16 @@ $(TR $(TDNW $(SUBMODULE allocation) $(BR)
      $(TD
         $(SUBREF allocation, makeNdarray)
         $(SUBREF allocation, makeSlice)
-        $(SUBREF allocation, makeUninitializedSlice)
+        $(SUBREF allocation, makeUninitSlice)
         $(SUBREF allocation, ndarray)
         $(SUBREF allocation, shape)
         $(SUBREF allocation, slice)
-        $(SUBREF allocation, uninitializedSlice)
+        $(SUBREF allocation, uninitAlignedSlice)
+        $(SUBREF allocation, uninitSlice)
         $(SUBREF allocation, stdcSlice)
+        $(SUBREF allocation, stdcFreeAlignedSlice)
         $(SUBREF allocation, stdcFreeSlice)
+        $(SUBREF allocation, stdcUninitAlignedSlice)
         $(SUBREF allocation, stdcUninitSlice)
     )
 )
@@ -143,6 +146,7 @@ $(TR $(TDNW $(SUBMODULE topology) $(BR)
         $(SUBREF topology, map)
         $(SUBREF topology, mapSubSlices)
         $(SUBREF topology, magic)
+        $(SUBREF topology, member)
         $(SUBREF topology, ndiota)
         $(SUBREF topology, pack)
         $(SUBREF topology, pairwise)

source/mir/ndslice/topology.d

@@ -45,6 +45,7 @@ $(T2 diff, Differences between vector elements.)
 $(T2 flattened, Contiguous 1-dimensional slice of all elements of a slice.)
 $(T2 map, Multidimensional functional map.)
 $(T2 mapSubSlices, Maps indexes pairs to subslices.)
+$(T2 member, Field (element's member) projection.)
 $(T2 pairwise, Pairwise map for vectors.)
 $(T2 pairwiseMapSubSlices, Maps pairwise indexes pairs to subslices.)
 $(T2 retro, Reverses order of iteration for all dimensions.)
@@ -5291,3 +5292,66 @@ version(mir_test) unittest
     auto x = slice.byDim!0;
     assert(x == slice);
 }
+
+/++
+Field (element's member) projection.
+
+Params:
+    name = element's member name
+Returns:
+    lazy n-dimensional slice of the same shape
+See_also:
+    $(LREF map)
++/
+
+template member(string name)
+    if (name.length)
+{
+    /++
+    Params:
+        slice = n-dimensional slice composed of structs, classes or unions
+    Returns:
+        lazy n-dimensional slice of the same shape
+    +/
+    Slice!(kind, packs, MemberIterator!(Iterator, name)) member(SliceKind kind, size_t[] packs, Iterator)(Slice!(kind, packs, Iterator) slice)
+    {
+        return typeof(return)(slice._lengths, slice._strides, MemberIterator!(Iterator, name)(slice._iterator));
+    }
+}
+
+///
+@safe pure unittest
+{
+    // struct, union or class
+    struct S
+    {
+        // Property support
+        // Getter always must be defined.
+        double _x;
+        double x() @property
+        {
+            return x;
+        }
+        void x(double x) @property
+        {
+            _x = x;
+        } 
+
+        /// Field support
+        double y;
+
+        /// Zero argument function support
+        double f()
+        {
+            return _x * 2;
+        }
+    }
+
+    import mir.ndslice.allocation: slice;
+    import mir.ndslice.topology: iota;
+
+    auto matrix = slice!S(2, 3);
+    matrix.member!"x"[] = [2, 3].iota;
+    matrix.member!"y"[] = matrix.member!"f";
+    assert(matrix.member!"y" == [2, 3].iota * 2);
+}