Steven Blenkinsop
September 1, 2018
This response concerns generic types which are found in the signatures of methods on the inputs to a contract which are not themselves inputs to the contract, for example the type of elem in elem := stack.Pop(), where the type of stack is an input to the contract. It suggests formalizing these types as part of the signature of a contract, like
| use std::any::Any; | |
| trait Schema { | |
| fn eq(&self, other: &Schema) -> bool; | |
| fn as_any(&self) -> &Any; | |
| } | |
| impl PartialEq<Schema> for Schema { | |
| fn eq(&self, other: &Schema) -> bool { | |
| Schema::eq(self, other) |
| use std::any::Any; | |
| trait Schema { | |
| fn eq(&self, other: &Schema) -> bool; | |
| fn as_any(&self) -> &Any; | |
| } | |
| impl<'a, 'b> PartialEq<Schema+'b> for Schema+'a { | |
| fn eq(&self, other: &(Schema+'b)) -> bool { | |
| Schema::eq(self, other) |
| fn old() -> Vec<u8> { | |
| let mut hash = vec![0u8; 8]; // vec of u8 representing the bits and bytes of the hash computed for the image. | |
| let raw: Vec<_> = (0..8).flat_map(|_| (0 .. 9).rev()).collect(); // vec of u8 representing gray pixels of an 9x8 image. | |
| for x in 0..8 { | |
| for y in 0..8 { | |
| if raw[x*9+y] > raw[x*9+y+1] { | |
| hash[x] |= 0x1 << y | |
| } |
| fn main() { | |
| #![allow(unused)] | |
| // A borrow can be moved out of the scope where it is created as long as the original value is | |
| // known to live long enough. Here it is assigned to `out`. While `out` is in scope, `x` is | |
| // inaccessible. When `out` goes out of scope, `x` becomes accessible again: | |
| { | |
| fn bar<'a>(x: &'a mut u32) -> &'a mut u32 { x } | |
| let mut x = 1; | |
| { |
| fn old() -> Vec<u8> { | |
| let mut hash = vec![0u8; 8]; // vec of u8 representing the bits and bytes of the hash computed for the image. | |
| let raw: Vec<_> = (0..8).flat_map(|_| (0 .. 9).rev()).collect(); // vec of u8 representing gray pixels of an 9x8 image. | |
| for x in 0..8 { | |
| for y in 0..8 { | |
| if raw[x*9+y] > raw[x*9+y+1] { | |
| hash[x] |= 0x1 << y | |
| } |
| use std::marker::PhantomData; | |
| struct Nothing; | |
| #[allow(dead_code)] | |
| struct Neg; | |
| struct Zero<T: Num>(PhantomData<T>); | |
| struct One<T: Num>(PhantomData<T>); |
| trait T<'a> { | |
| type A; | |
| type Iter: Iterator<Item=Self::A>; | |
| fn new() -> Self; | |
| fn iter(&self) -> Self::Iter; | |
| fn test() where Self: Sized { | |
| let a = <Self as T<'a>>::new(); | |
| let _ = a.iter().map(|a| a); |
| fn function(_x: &i32) -> &i32 { &5th } | |
| fn main() { | |
| function(); | |
| } |
| use std::ops::Deref; | |
| fn main() { | |
| let s: &'static str = "hello"; | |
| let x: &'static str = &*s; | |
| let y: &'static str = s.deref(); // <-- lifetime error | |
| } |