Title: RFC: Array Reference Type · Issue #879 · rust-ndarray/ndarray · GitHub
Open Graph Title: RFC: Array Reference Type · Issue #879 · rust-ndarray/ndarray
X Title: RFC: Array Reference Type · Issue #879 · rust-ndarray/ndarray
Description: Please post your thoughts, or let me know if something is unclear/confusing! Summary This RFC proposes the addition of a new storage type RefRepr and associated type aliases ArrayRef, ArrayRef1, ArrayRef2, etc., such that we ...
Open Graph Description: Please post your thoughts, or let me know if something is unclear/confusing! Summary This RFC proposes the addition of a new storage type RefRepr and associated type aliases ArrayRef, ArrayRe...
X Description: Please post your thoughts, or let me know if something is unclear/confusing! Summary This RFC proposes the addition of a new storage type RefRepr and associated type aliases ArrayRef<A, D>, A...
Opengraph URL: https://github.com/rust-ndarray/ndarray/issues/879
X: @github
Domain: github.com
{"@context":"https://schema.org","@type":"DiscussionForumPosting","headline":"RFC: Array Reference Type","articleBody":"Please post your thoughts, or let me know if something is unclear/confusing!\r\n\r\n# Summary\r\n\r\nThis RFC proposes the addition of a new storage type `RefRepr` and associated type aliases `ArrayRef\u003cA, D>`, `ArrayRef1\u003cA>`, `ArrayRef2\u003cA>`, etc., such that we can implement the following traits:\r\n\r\n- `Borrow\u003cArrayRef\u003cA, D>>` for `ArrayBase\u003cS, D> where S: Data`\r\n- `Deref\u003cTarget = ArrayRef\u003cA, D>>` for `ArrayBase\u003cS, D> where S: Data`\r\n- `BorrowMut\u003cArrayRef\u003cA, D>>` for `ArrayBase\u003cS, D> where S: DataMut`\r\n- `DerefMut\u003cTarget = ArrayRef\u003cA, D>>` for `ArrayBase\u003cS, D> where S: DataMut`\r\n- `ToOwned\u003cOwned = Array\u003cA, D>>` for `ArrayRef\u003cA, D>`\r\n\r\n`&'a ArrayRef\u003cA, D>` would be analogous to `ArrayView\u003c'a, A, D>`, and `&'a mut ArrayRef\u003cA, D>` would be analogous to `ArrayViewMut\u003c'a, A, D>`.\r\n\r\nMany of the methods on `ArrayBase` would be moved to be implemented only on `ArrayRef` instead, and be available through deref coercion, similar to how much of the functionality of `Vec\u003cT>` is actually implemented on `[T]`.\r\n\r\n# Motivation\r\n\r\n## Good way to express function parameters\r\n\r\nConsider a function that needs a view of a 2-D array of `f64` elements. With current `ndarray`, we have the following ways to express this:\r\n\r\n```rust\r\n// Option 1\r\nfn function\u003cS>(arr: &ArrayBase\u003cS, Ix2>)\r\nwhere\r\n S: Data\u003cElem = f64>,\r\n{}\r\n\r\n// Option 2\r\nfn function\u003c'a, V: AsArray\u003c'a, f64, Ix2>>(arr: V) {}\r\n\r\n// Option 3\r\nfn function\u003c'a>(arr: impl AsArray\u003c'a, f64, Ix2>) {}\r\n\r\n// Option 4\r\nfn function(arr: ArrayView2\u003c'_, f64>) {}\r\n```\r\n\r\nEach of these has disadvantages:\r\n\r\n- Options 1 and 2 are verbose, and become particularly bad for functions taking many array parameters.\r\n\r\n- Option 4 is unnatural for callers of the function. (In most cases, they have to call `.view()` on the argument, which is verbose and is different from most Rust code, which typically uses references for this use-case.)\r\n\r\n- Options 1, 2, and 3 are generic, so they suffer from monomorphization bloat, as discussed in the next section. For functions taking multiple array parameters, it's even worse—the number of possible type combinations is exponential in the number of array parameters. (To minimize the bloat, it's necessary to create an inner function like option 4, and make the outer function convert the parameter(s) to `ArrayView` and call the inner function.)\r\n\r\nWith this RFC, it will be possible to express the function like this:\r\n\r\n```rust\r\nfn function(arr: &ArrayRef2\u003cf64>) {}\r\n```\r\n\r\nThis is more concise than the other options, and it's not generic, so there is no monomorphization bloat.\r\n\r\nMutable views would be handled similarly, just with `&mut` instead of `&`.\r\n\r\n## Substantially reduce monomorphization bloat\r\n\r\nMost of the functionality of `ndarray` is currently implemented as methods on `ArrayBase\u003cS, D>`. As a result, the methods are monomorphized for each new combination of `S` and `D` types, which means that there's a lot of nearly-identical generated code, i.e. \"monomorphization bloat\". The same issue occurs for crates which provide extension traits, such as `ndarray-linalg`, `ndarray-stats`, and `ndarray-npy`. (It's possible to minimize monomorphization bloat for a method by changing it to convert everything to `ArrayView/Mut` and then call an inner function which takes `ArrayView/Mut` parameters. However, that's very verbose and tedious.)\r\n\r\nIf, instead, we move most functionality to be implemented only on `ArrayRef\u003cA, D>`, analogous to how much of the functionality of `Vec\u003cT>` is actually implemented on `[T]`, then the monomorphization bloat due to differing storage types would be eliminated. (Callers would rely on deref coercion, like they do for methods actually implemented on `[T]` for `Vec\u003cT>`.)\r\n\r\n## Enable in-place arithmetic operator syntax for the result of a slicing operation\r\n\r\nCurrently, it's not possible to use in-place arithmetic operator syntax for the results of slicing operations; instead, it's necessary to call the appropriate method:\r\n\r\n```rust\r\nlet mut a = array![0, 1, 2, 3, 4];\r\n\r\n// Compiles:\r\nuse std::ops::AddAssign;\r\na.slice_mut(s![1..3]).add_assign(1);\r\n\r\n// Doesn't compile:\r\n*a.slice_mut(s![1..3]) += 1;\r\n```\r\n\r\nThe error message is\r\n\r\n```\r\nerror[E0614]: type `ArrayBase\u003cViewRepr\u003c&mut {integer}>, Dim\u003c[usize; 1]>>` cannot be dereferenced\r\n --> src/main.rs:11:5\r\n |\r\n11 | *a.slice_mut(s![1..3]) += 1;\r\n | \r\n```\r\n\r\nBy making `ArrayBase` dereference to `ArrayRef` and implementing the in-place arithmetic operators on `ArrayRef`, this will compile without errors.\r\n\r\n## Better integration into the Rust ecosystem\r\n\r\nThe existing Rust ecosystem provides functionality dependent on traits like `Borrow`. Implementing these traits will allow `ndarray` to interact more cleanly with the rest of the ecosystem. See #878 for one example.\r\n\r\n# Guide-level explanation\r\n\r\nIn many ways, an owned array `Array\u003cA, D>` is similar to `Vec\u003cA>`. It is an allocated container for a collection of elements.\r\n\r\nThe new `ArrayRef\u003cA, D>` type for arrays is analogous to the `[A]` (i.e. slice) type for vectors. Arrays dereference to `ArrayRef\u003cA, D>`, like `Vec\u003cA>` derefs to `[A]`, so functionality available for `ArrayRef\u003cA, D>` is available for other array types through deref coercion, like how functionality available for `[A]` is available for `Vec\u003cA>` through deref coercion.\r\n\r\nWhen writing a function, you should use `&ArrayRef\u003cA, D>` or `&mut ArrayRef\u003cA, D>` as the parameter types when possible, similar to how you'd use `&[A]` or `&mut [A]` instead of `&Vec\u003cA>` or `&mut Vec\u003cA>`.\r\n\r\nIn general, handle `ArrayRef\u003cA, D>` analogously to how you'd handle `[A]`. The primary ways in which they are not analogous are the following:\r\n\r\n- `ArrayRef\u003cA, D>` is `Sized`, unlike `[A]`. As a result, `&ArrayRef\u003cA, D>` is a thin pointer, while `&[A]` is a thick pointer.\r\n\r\n- Due to technical limitations, given an array it's not possible to *directly* create an `&ArrayRef` that is a view of a portion of the array. In other words, you can create a slice (i.e. `&[A]`) of a portion of a `&[A]`/`Vec\u003cA>` with indexing, e.g. `&var[3..12]`, but this is not possible for `&ArrayRef`. In order to create an `&ArrayRef` that references a portion of an array, you have to first create an `ArrayView` (by slicing, etc.), and then coerce that `ArrayView` to `ArrayRef`.\r\n\r\nAlso note that `&'a ArrayRef\u003cA, D>` is similar to `ArrayView\u003c'a, A, D>`, and `&'a mut ArrayRef\u003cA, D>` is similar to `ArrayViewMut\u003c'a, A, D>`, with the following exceptions:\r\n\r\n- You don't have call a method like `.reborrow()` (for `ArrayView/Mut`) to manually shorten the lifetime of the borrow. The lifetimes of references to `ArrayRef` will be automatically adjusted as necessary, just like other references in Rust.\r\n\r\n- The shape, strides, and pointer of an `&ArrayRef\u003cA, D>` or `&mut ArrayRef\u003cA, D>` cannot be modified. For example, you can't call `.slice_axis_inplace()`. To get an array with different shape/strides/pointer, you have to create a view. For example, you could call `.slice_axis()`, or you could create a view with `.view()` and then call `.slice_axis_inplace()` on the view.\r\n\r\n# Implementation\r\n\r\n## Implementing `Deref` and `DerefMut` with `Target = ArrayRef\u003cA, D>`\r\n\r\nThe new `RefRepr` storage type will be:\r\n\r\n```rust\r\n#[repr(C)]\r\npub struct RefRepr\u003cA> {\r\n elem: PhantomData\u003cA>,\r\n}\r\n```\r\n\r\nThe `ArrayBase` struct will be changed to the following:\r\n\r\n```rust\r\n#[repr(C)]\r\npub struct ArrayBase\u003cS, D>\r\nwhere\r\n S: RawData,\r\n{\r\n dim: D,\r\n strides: D,\r\n ptr: NonNull\u003cS::Elem>,\r\n data: S,\r\n}\r\n```\r\n\r\nThe important parts of this change are:\r\n\r\n- The `dim`, `strides`, and `ptr` fields are the first fields in the struct.\r\n\r\n- The struct is declared `repr(C)`.\r\n\r\nThese changes are necessary so that it's possible to implement `Deref` and `DerefMut` by casting references to `ArrayBase` into references to `ArrayRef`.\r\n\r\n@bluss pointed out below that it's necessary to avoid infinite recursion in deref coercion. To do this, a `DataDeref` trait will be added:\r\n\r\n```rust\r\npub unsafe trait DataDeref: Data {}\r\n```\r\n\r\nThis trait will be implemented by all storage types except for `RefRepr` and will be used as a bound for the `Deref` and `DerefMut` implementations.\r\n\r\n`Deref` and `DerefMut` will be implemented like this:\r\n\r\n```rust\r\nimpl\u003cA, S, D> Deref for ArrayBase\u003cS, D>\r\nwhere\r\n S: Data\u003cElem = A> + DataDeref,\r\n{\r\n type Target = ArrayRef\u003cA, D>;\r\n\r\n fn deref(&self) -> &ArrayRef\u003cA, D> {\r\n unsafe {\r\n &*(self as *const Self).cast::\u003cArrayRef\u003cA, D>>()\r\n }\r\n }\r\n}\r\n\r\nimpl\u003cA, S, D> DerefMut for ArrayBase\u003cS, D>\r\nwhere\r\n S: DataMut\u003cElem = A> + DataDeref,\r\n{\r\n fn deref_mut(&mut self) -> &mut ArrayRef\u003cA, D> {\r\n self.ensure_unique();\r\n unsafe {\r\n &mut *(self as *mut Self).cast::\u003cArrayRef\u003cA, D>>()\r\n }\r\n }\r\n}\r\n```\r\n\r\n## Moving most existing methods to be implemented only for `ArrayRef\u003cA, D>`\r\n\r\nMost of the existing methods which don't modify the shape/strides/pointer (such as `slice`, `mapv`, etc.) will no longer be implemented for all `ArrayBase\u003cS, D>`, but rather will be implemented only on `ArrayRef\u003cA, D>`. This change isn't necessary in order to introduce the `ArrayRef` type, but it is necessary in order to reduce the existing monomorphization bloat, which is one of the primary benefits of the `ArrayRef` type.\r\n\r\n## Data traits for `RefRepr`\r\n\r\nThe `RefRepr` type will implement the following traits:\r\n\r\n- `RawData`\r\n- `RawDataMut`\r\n- `Data` (but make the `into_owned` implementation panic with `unreachable!()`)\r\n- `DataMut`\r\n- `RawDataSubs`\r\n\r\nIn other words, the `&'a` or `&'a mut` in a reference to an `ArrayRef` will control the lifetime and mutability of the data.\r\n\r\nWe need to audit all of the available methods to make sure that:\r\n\r\n- it's possible to create an `&'a ArrayRef\u003cA, D>` only for a base array with `S: Data` that lives at least as long as `'a`,\r\n- it's possible to create an `&'a mut ArrayRef\u003cA, D>` only for a base array with `S: DataMut` that lives at least as long as `'a`, and\r\n- it's not possible to create an `ArrayRef\u003cA, D>`\r\n\r\n(I believe this is already true if we just add the `Deref`, `DerefMut`, `Borrow`, and `BorrowMut` implementations, but we should check.)\r\n\r\n## Preventing modification of shape/strides/pointer via `&mut ArrayRef\u003cA, D>`\r\n\r\nTo minimize confusion and behave analogously to `&mut [A]`, it should not be possible to modify the underlying shape/strides/pointer through a `&mut ArrayRef\u003cA, D>`. For example,\r\n\r\n```rust\r\nlet mut owned: Array2\u003cf32> = Array::\u003cf32>::zeros((4, 5));\r\nlet mut borrowed: &mut ArrayRef\u003cA, D> = &mut owned;\r\n// should not compile since it would modify the shape/strides/pointer:\r\nborrowed.slice_axis_inplace(Axis(0), ..);\r\n```\r\n\r\nTo achieve this:\r\n\r\n- A new `MetaMut` trait will be added to control whether the shape/strides/pointer can be modified.\r\n\r\n- `MetaMut` will be implemented for all of the existing storage types (`OwnedRepr`, `ViewRepr`, etc.), but not the new `RefRepr` type.\r\n\r\n- A `S: MetaMut` bound will be added to all methods which modify the shape/strides/pointer in-place (such as `slice_collapse`, `slice_axis_inplace`, `collapse_axis`, `swap_axes`, `invert_axis`, `merge_axes`, `insert_axis_inplace`, and `index_axis_inplace`) .\r\n\r\n# Drawbacks\r\n\r\nThis proposal introduces yet another storage type, when `ndarray` already has quite a few.\r\n\r\nThe similarity of `&'a ArrayRef\u003cA, D>` to `ArrayView\u003c'a, A, D>` and `&'a mut ArrayRef\u003cA, D>` to `ArrayViewMut\u003c'a, A, D>` could be confusing to new users.\r\n\r\nThe requirement that it must be possible to create `ArrayRef` references by reinterpreting the bits in existing `ArrayBase` instances limits the possible field layouts of `ArrayBase`.\r\n\r\n# Rationale and alternatives\r\n\r\n## Allow mutation of the shape/strides/pointer for `&mut ArrayRef\u003cA, D>`\r\n\r\nIt would be possible to avoid the new `MetaMut` trait by allowing modification of the shape/strides/pointer through `&mut ArrayRef\u003cA, D>` instances. However, this would likely be confusing to users who are familiar with how `&mut [T]`/`Vec\u003cT>` behave, and it would increase the potential for bugs.\r\n\r\n## Keep most method implementations on all `ArrayBase\u003cS, D>`\r\n\r\nIt would be possible to keep the existing method implementations for all `ArrayBase\u003cS, D>` instead of moving them to be implemented only on `ArrayRef\u003cA, D>`. However, this would not bring the reduced monomorphization bloat which is one of the advantages of the new `ArrayRef` type.\r\n\r\n## Make `ArrayRef` be a separate struct from `ArrayBase`\r\n\r\nIt would be possible for `ArrayRef` to be a separate struct from `ArrayBase`, instead of an alias of `ArrayBase`. This would have the following advantages:\r\n\r\n- `Deref`, `DerefMut`, `Borrow`, and `BorrowMut` could be implemented for `ArrayBase` without `unsafe` code.\r\n- The `MetaMut` and `DataDeref` traits wouldn't be necessary.\r\n- There's less potential for unwanted overlapping or recursive trait impls.\r\n- Keeping the types separate may be less confusing for new users.\r\n\r\nThe disadvantages of a separate struct type are:\r\n\r\n- The transition to `ArrayRef` would be more disruptive. Until libraries update their functions to take `&ArrayRef` or `&mut ArrayRef` parameters instead of `&ArrayBase` or `&mut ArrayBase` parameters, `ArrayRef` would not be compatible with those functions. (Users of those libraries would likely have to call `.view()`/`.view_mut()` in some places.)\r\n\r\n- It may be less convenient for generic code which wants to operate on all array types.\r\n \r\n For example, if `ArrayRef` is *not* a separate struct, then these impls are sufficient for `AddAssign`:\r\n\r\n ```rust\r\n impl\u003c'b, A, B, S2, D1, D2> AddAssign\u003c&'b ArrayBase\u003cS2, D2>> for ArrayRef\u003cA, D1>\r\n where\r\n A: AddAssign\u003c&'b B>,\r\n B: 'b,\r\n S2: Data\u003cElem = B>,\r\n D1: Dimension,\r\n D2: Dimension,\r\n {}\r\n\r\n impl\u003cA, B, D> AddAssign\u003cB> for ArrayRef\u003cA, D>\r\n where\r\n A: AddAssign\u003cB>,\r\n B: ScalarOperand,\r\n D: Dimension,\r\n {}\r\n ```\r\n\r\n (Note that, unfortunately, we can't replace `impl\u003c'b, A, B, S2, D1, D2> AddAssign\u003c&'b ArrayBase\u003cS2, D2>> for ArrayRef\u003cA, D1>` with `impl\u003c'b, A, B, D1, D2> AddAssign\u003c&'b ArrayRef\u003cB, D2>> for ArrayRef\u003cA, D1>`. For some reason, the compiler has trouble figuring out which impl to use when `impl\u003cA, B, D> AddAssign\u003cB> for ArrayRef\u003cA, D>` also exists.)\r\n\r\n However, if `ArrayRef` is a separate struct, then it would be necessary to add another impl:\r\n\r\n ```rust\r\n impl\u003c'b, A, B, D1, D2> AddAssign\u003c&'b ArrayRef\u003cB, D2>> for ArrayRef\u003cA, D1>\r\n where\r\n A: AddAssign\u003c&'b B>,\r\n B: 'b,\r\n D1: Dimension,\r\n D2: Dimension,\r\n {}\r\n ```\r\n\r\n## Custom DST (i.e. custom thick pointer types)\r\n\r\nInstead of using thin pointers to `ArrayRef`, we could wait for custom DSTs (e.g. [RFC 2594](https://github.com/rust-lang/rfcs/pull/2594)) to be added to Rust, and then create a custom DST similar to `ArrayRef`. This would have the following advantages:\r\n\r\n- Since the shape/strides/pointer would be stored within the thick pointer, it would be possible to modify the shape/strides/pointer in the thick pointer in-place, unlike for a reference to an `ArrayRef`.\r\n\r\n- Slicing methods could return a thick pointer instead of an `ArrayView/Mut` except in the `IxDyn` case.\r\n\r\n- *Raw* thick pointers (i.e. `*const`/`*mut`) would be more useful. In other words, since the shape/strides would be stored within the thick pointer itself, it should be possible to access that information without dereferencing the pointer. So, except in the `IxDyn` case, thick pointers could replace `RawArrayView/Mut`. In contrast, given a `*const ArrayRef\u003cA, D>` or `*mut ArrayRef\u003cA, D>`, you have to dereference the pointer to access the shape/strides, so `ArrayRef` cannot replace most uses of `RawArrayView/Mut`.\r\n\r\nHowever, I'm not aware of any Rust RFC for custom DSTs which would make it possible to create a custom DST with support for the dynamic-dimensional (`IxDyn`) case. So, there would be this weird dichotomy between the convenience of thick pointers for the const-dimensional case and the complexity of the dynamic-dimensional case. In contrast, the `ArrayRef` type proposed in this RFC would support the const-dimensional and dynamic-dimensional cases in a uniform way.\r\n\r\n# Future possibilities\r\n\r\nOne thing I wanted to make sure when writing this proposal was that it would still allow replacing the `ArrayBase` struct with a trait-based API in the future. In other words, if we had\r\n\r\n```rust\r\nstruct Array\u003cA, D> { ... }\r\n\r\nstruct ArrayView\u003c'a, A, D> { ... }\r\n\r\n// ...\r\n\r\ntrait NdArray { ... }\r\n\r\ntrait NdArrayMut { ... }\r\n\r\n// ...\r\n```\r\n\r\ninstead of having all arrays be instances of `ArrayBase`, it would be nice for this proposal to still apply. This proposal would, in fact, be compatible with a trait-based API, and the implementation could be somewhat cleaner because it wouldn't require any `unsafe` code. I'd suggest implementing the types like this:\r\n\r\n```rust\r\nstruct Array\u003cA, D> {\r\n meta: ArrayRef\u003cA, D>,\r\n data: Vec\u003cA>,\r\n}\r\n\r\nstruct ArrayView\u003c'a, A, D> {\r\n meta: ArrayRef\u003cA, D>,\r\n life: PhantomData\u003c&'a A>,\r\n}\r\n\r\nstruct ArrayRef\u003cA, D> {\r\n shape: D,\r\n strides: D,\r\n ptr: NonNull\u003cA>,\r\n}\r\n\r\nimpl\u003cA, D> Deref for Array\u003cA, D> {\r\n type Target = ArrayRef\u003cA, D>;\r\n\r\n fn deref(&self) -> &ArrayRef\u003cA, D> {\r\n &self.meta\r\n }\r\n}\r\n\r\n// ...\r\n```\r\n","author":{"url":"https://github.com/jturner314","@type":"Person","name":"jturner314"},"datePublished":"2021-01-04T03:42:30Z","url":"https://github.com/rust-ndarray/ndarray/issues/879"}
| react-profiling | 0 |
| react-import-map | react,react-dom,react-dom/client,react-dom/profiling,react-is,react/compiler-runtime,react/jsx-dev-runtime,react/jsx-runtime,scheduler@b8488ee2c322 |
| route-pattern | /_view_fragments/issues/show/:user_id/:repository/:id/issue_layout(.:format) |
| route-controller | voltron_issues_fragments |
| route-action | issue_layout |
| fetch-nonce | v2:20b2c0f6-e44d-99d8-84f3-bc8387a73868 |
| current-catalog-service-hash | 81bb79d38c15960b92d99bca9288a9108c7a47b18f2423d0f6438c5b7bcd2114 |
| request-id | B37C:214E9D:5DD3F:865D4:6AFD488B |
| html-safe-nonce | 50ad0be7734b84a37ab8e2519be70cd1a1bc8ac055cf79127892580a8f17620e |
| visitor-payload | eyJyZWZlcnJlciI6IiIsInJlcXVlc3RfaWQiOiJCMzdDOjIxNEU5RDo1REQzRjo4NjVENDo2QUZENDg4QiIsInZpc2l0b3JfaWQiOiIyMDMzMzIzMjM0MzgzNzEwMzQ3IiwicmVnaW9uX2VkZ2UiOiJpYWQiLCJyZWdpb25fcmVuZGVyIjoiaWFkIn0= |
| visitor-hmac | 0152de1abf8a35c18cadd1ed8c7182fd086765cdb4c48081190b7b775b59545f |
| hovercard-subject-tag | issue:777792827 |
| github-keyboard-shortcuts | repository,issues,copilot |
| google-site-verification | Apib7-x98H0j5cPqHWwSMm6dNU4GmODRoqxLiDzdx9I |
| octolytics-url | https://collector.github.com/github/collect |
| analytics-location | / |
| fb:app_id | 1401488693436528 |
| apple-itunes-app | app-id=1477376905, app-argument=https://github.com/_view_fragments/issues/show/rust-ndarray/ndarray/879/issue_layout |
| twitter:image | https://opengraph.githubassets.com/34e5657d36d2a42c8a2fe5a14b6b7cff5b751e67d87090f81e2898b39bf30983/rust-ndarray/ndarray/issues/879 |
| twitter:card | summary_large_image |
| og:image | https://opengraph.githubassets.com/34e5657d36d2a42c8a2fe5a14b6b7cff5b751e67d87090f81e2898b39bf30983/rust-ndarray/ndarray/issues/879 |
| og:image:alt | Please post your thoughts, or let me know if something is unclear/confusing! Summary This RFC proposes the addition of a new storage type RefRepr and associated type aliases ArrayRef, ArrayRe... |
| og:image:width | 1200 |
| og:image:height | 600 |
| og:site_name | GitHub |
| og:type | object |
| og:author:username | jturner314 |
| hostname | github.com |
| expected-hostname | github.com |
| None | 66653c2e55a6fff2930be1bdf07ee4f8aa137e3956d056c822563be6f878755e |
| turbo-cache-control | no-preview |
| go-import | github.com/rust-ndarray/ndarray git https://github.com/rust-ndarray/ndarray.git |
| octolytics-dimension-user_id | 44419403 |
| octolytics-dimension-user_login | rust-ndarray |
| octolytics-dimension-repository_id | 22598813 |
| octolytics-dimension-repository_nwo | rust-ndarray/ndarray |
| octolytics-dimension-repository_public | true |
| octolytics-dimension-repository_is_fork | false |
| octolytics-dimension-repository_network_root_id | 22598813 |
| octolytics-dimension-repository_network_root_nwo | rust-ndarray/ndarray |
| turbo-body-classes | logged-out env-production page-responsive |
| disable-turbo | false |
| browser-stats-url | https://api.github.com/_private/browser/stats |
| browser-errors-url | https://api.github.com/_private/browser/errors |
| release | b6f01f7cb9f35f8c09949773241a3d49dd04b340 |
| ui-target | canary-2 |
| theme-color | #1e2327 |
| color-scheme | light dark |
| react-app-name | issues |
Links:
Viewport: width=device-width