Just a comment about -g2 if const fn never materializes

nugget_bls/any_tools/Cargo.toml

@@ -0,0 +1,8 @@
+[package]
+name = "any_tools"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]

nugget_bls/any_tools/README.md

@@ -0,0 +1,3 @@
+Very unfinsihed, but if const fn were going to take too long
+then ideas here combined with lazy_static gives a substitute.
+

nugget_bls/any_tools/src/lib-1.rs

@@ -0,0 +1,44 @@
+
+use ark_std::any::Any;
+
+// use std::{any::Any};
+
+pub struct AnyLinkedList {
+    fence:
+    start: AnyLLPtr,
+}
+
+pub type AnyLLPtr = AnyLL<dyn Any>;
+
+pub struct AnyLL<T: ?Sized + 'static> {
+    next: AnyLLPtr,
+    any: T,
+}
+
+impl AnyLL<dyn Any> {
+    pub fn try_fetch<'a,T: 'static>(&'a self) -> Option<&'a T> {
+        let mut selfy: &'a Self = self;
+        loop {
+            if let Some(r) = selfy.any.downcast_ref::<T>() { return Some(r); }
+            if selfy.next.is_none() { return None; }
+            selfy = selfy.next.as_ref().unwrap()
+        }
+    }
+
+    pub fn fetch_or_extend<'a,T: 'static,F: FnOnce() -> T>(&'a mut self, init: F) -> &'a T {
+        let mut selfy: &'a mut Self = self;
+        loop {
+            if let Some(r) = selfy.any.downcast_ref::<T>() { return r; }
+            if selfy.next.is_none() {
+                let b = Box::new(AnyLL { next: None, any: init(), });
+                let new = unsafe { core::mem::transmute(&b.any) };  
+                selfy.next = Some(b as Box<AnyLL<dyn Any>>);
+                return new;
+                // We deduce the above code is safe because you could comment
+                // the two lines containing new and uncomment the line below:
+                // return selfy.next.as_mut().unwrap().any.downcast_ref::<T>().unwrap();
+            }
+            selfy = selfy.next.as_mut().unwrap()
+        }
+    }
+}

nugget_bls/any_tools/src/lib.rs

@@ -0,0 +1,57 @@
+
+
+use ark_std::any::Any;
+
+// use std::{any::Any};
+
+pub struct AnyLinkedList {
+    fence:
+    start: AnyLLPtr,
+}
+
+pub type AnyLLPtr = Cell<Option<Box<AnyLL<dyn Any>>>>;
+
+pub struct AnyLL<T: ?Sized + 'static> {
+    next: AnyLLPtr,
+    any: T,
+}
+
+impl AnyLL<dyn Any> {
+    pub fn try_fetch<'a,T: 'static>(&'a self) -> Option<&'a T> {
+        let mut selfy: &'a Self = self;
+        loop {
+            if let Some(r) = selfy.any.downcast_ref::<T>() { return Some(r); }
+            if selfy.next.is_none() { return None; }
+            selfy = selfy.next.as_ref().unwrap()
+        }
+    }
+
+    pub fn fetch_or_extend<'a,T: 'static,F: FnOnce() -> T>(&'a mut self, init: F) -> &'a T {
+        let mut selfy: &'a mut Self = self;
+        loop {
+            if let Some(r) = selfy.any.downcast_ref::<T>() { return r; }
+            if selfy.next.is_none() {
+                let b = Box::new(AnyLL { next: None, any: init(), });
+                let new = unsafe { core::mem::transmute(&b.any) };  
+                selfy.next = Some(b as Box<AnyLL<dyn Any>>);
+                return new;
+                // We deduce the above code is safe because you could comment
+                // the two lines containing new and uncomment the line below:
+                // return selfy.next.as_mut().unwrap().any.downcast_ref::<T>().unwrap();
+            }
+            selfy = selfy.next.as_mut().unwrap()
+        }
+    }
+}
+
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn it_works() {
+        let result = add(2, 2);
+        assert_eq!(result, 4);
+    }
+}

nugget_bls/src/lib.rs

@@ -181,6 +181,10 @@ pub struct AggregateSignature<P: Pairing> {
     agg_pk_g2: <P as Pairing>::G2Affine,
 }
 
+// TODO:  We could precomute g2_minus_generator using lazy_static and
+// the AnyLinkedList trick in nugget_bls/any_tools/src, but const fn
+// should work eventually, so likely overkill now.
+
 fn g2_minus_generator<P: Pairing>() -> <P as Pairing>::G2Prepared {
     prepare_g2::<P>(- pk_in::<P>().0.into_group())
 }