Target generation, ideally, to those files we'll need for doing crypto.

generation/src/Add.hs

@@ -10,7 +10,6 @@ module Add(
 import Data.Bits((.&.))
 import Data.Map.Strict(Map)
 import qualified Data.Map.Strict as Map
-import Gen(toLit)
 import Generators
 import Language.Rust.Data.Ident
 import Language.Rust.Data.Position
@@ -22,6 +21,7 @@ import System.Random(RandomGen)
 safeAddOps :: RustModule
 safeAddOps = RustModule {
     predicate = \ me others -> (me + 64) `elem` others,
+    suggested = \ me -> [me + 64],
     outputName = "safe_add",
     isUnsigned = True,
     generator = declareSafeAddOperators,
@@ -31,6 +31,7 @@ safeAddOps = RustModule {
 unsafeAddOps :: RustModule
 unsafeAddOps = RustModule {
     predicate = \ _ _ -> True,
+    suggested = const [],
     outputName = "unsafe_add",
     isUnsigned = True,
     generator = declareUnsafeAddOperators,
@@ -40,6 +41,7 @@ unsafeAddOps = RustModule {
 safeSignedAddOps :: RustModule
 safeSignedAddOps = RustModule {
     predicate = \ me others -> (me + 64) `elem` others,
+    suggested = \ me -> [me + 64],
     outputName = "safe_sadd",
     isUnsigned = False,
     generator = declareSafeSignedAddOperators,
@@ -49,6 +51,7 @@ safeSignedAddOps = RustModule {
 unsafeSignedAddOps :: RustModule
 unsafeSignedAddOps = RustModule {
     predicate = \ _ _ -> True,
+    suggested = const [],
     outputName = "unsafe_sadd",
     isUnsigned = False,
     generator = declareUnsafeSignedAddOperators,

generation/src/Base.hs

@@ -13,6 +13,7 @@ import RustModule
 base :: RustModule
 base = RustModule {
   predicate = \ _ _ -> True,
+  suggested = const [],
   outputName = "base",
   isUnsigned = True,
   generator = declareBaseStructure,

generation/src/BinaryOps.hs

@@ -7,7 +7,6 @@ module BinaryOps(
 import Data.Bits(xor,(.&.),(.|.))
 import Data.Map.Strict(Map)
 import qualified Data.Map.Strict as Map
-import Gen(toLit)
 import Generators
 import Language.Rust.Data.Ident
 import Language.Rust.Data.Position
@@ -19,6 +18,7 @@ import System.Random(RandomGen)
 binaryOps :: RustModule
 binaryOps = RustModule {
     predicate = \ _ _ -> True,
+    suggested = const [],
     outputName = "binary",
     isUnsigned = True,
     generator = declareBinaryOperators,

generation/src/Compare.hs

@@ -15,6 +15,7 @@ import System.Random(RandomGen)
 comparisons :: RustModule
 comparisons = RustModule {
   predicate = \ _ _ -> True,
+  suggested = const [],
   outputName = "compare",
   isUnsigned = True,
   generator = declareComparators,
@@ -24,6 +25,7 @@ comparisons = RustModule {
 signedComparisons :: RustModule
 signedComparisons = RustModule {
   predicate = \ _ _ -> True,
+  suggested = const [],
   outputName = "scompare",
   isUnsigned = False,
   generator = declareSignedComparators,

generation/src/Conversions.hs

@@ -5,7 +5,7 @@ module Conversions(
   )
  where
 
-import Gen(toLit)
+import Generators
 import Language.Rust.Data.Ident
 import Language.Rust.Data.Position
 import Language.Rust.Quote
@@ -15,6 +15,7 @@ import RustModule
 conversions :: RustModule
 conversions = RustModule {
   predicate = \ _ _ -> True,
+  suggested = const [],
   outputName = "conversions",
   isUnsigned = True,
   generator = declareConversions,
@@ -24,6 +25,7 @@ conversions = RustModule {
 signedConversions :: RustModule
 signedConversions = RustModule {
   predicate = \ _ _ -> True,
+  suggested = const [],
   outputName = "sconversions",
   isUnsigned = False,
   generator = declareSignedConversions,

generation/src/CryptoNum.hs

@@ -7,7 +7,6 @@ module CryptoNum(
 import Data.Bits(testBit)
 import Data.Map.Strict(Map)
 import qualified Data.Map.Strict as Map
-import Gen
 import Generators
 import Language.Rust.Data.Ident
 import Language.Rust.Data.Position
@@ -19,6 +18,7 @@ import System.Random(RandomGen)
 cryptoNum :: RustModule
 cryptoNum = RustModule {
   predicate = \ _ _ -> True,
+  suggested = const [],
   outputName = "cryptonum",
   isUnsigned = True,
   generator = declareCryptoNumInstance,

generation/src/Division.hs

@@ -4,7 +4,6 @@ module Division(divisionOps)
 
 import Data.Map.Strict(Map)
 import qualified Data.Map.Strict as Map
-import Gen(toLit)
 import Generators
 import Language.Rust.Data.Ident
 import Language.Rust.Data.Position
@@ -16,6 +15,7 @@ import System.Random(RandomGen)
 divisionOps :: RustModule
 divisionOps = RustModule {
     predicate = \ _ _ -> True,
+    suggested = const [],
     outputName = "divmod",
     isUnsigned = True,
     generator = declareDivision,

generation/src/Gen.hs

@@ -1,13 +0,0 @@
-{-# LANGUAGE GeneralizedNewtypeDeriving #-}
-module Gen(
-    toLit
-    )
- where
-
-import Language.Rust.Data.Position
-import Language.Rust.Syntax
-
-toLit :: Word -> Expr Span
-toLit i = Lit  [] (Int Dec (fromIntegral i) Unsuffixed mempty) mempty
-
-

generation/src/Generators.hs

@@ -1,9 +1,14 @@
 module Generators
  where
 
+import Language.Rust.Data.Position
+import Language.Rust.Syntax
 import Numeric(showHex)
 import System.Random(RandomGen,random,randomR)
 
+toLit :: Word -> Expr Span
+toLit i = Lit  [] (Int Dec (fromIntegral i) Unsuffixed mempty) mempty
+
 generateNum :: RandomGen g => g -> Word -> (Integer, g)
 generateNum g size =
   let (x, g') = random g

generation/src/ModInv.hs

@@ -20,6 +20,7 @@ import System.Random(RandomGen)
 generateModInvOps :: RustModule
 generateModInvOps = RustModule {
     predicate = \ me others -> (me + 64) `elem` others,
+    suggested = \ me -> [me + 64],
     outputName = "modinv",
     isUnsigned = True,
     generator = declareModInv,

generation/src/ModOps.hs

@@ -16,6 +16,7 @@ import System.Random(RandomGen)
 modulusOps :: RustModule
 modulusOps = RustModule {
     predicate = \ me others -> (me * 2) `elem` others,
+    suggested = \ me -> [me * 2],
     outputName = "modops",
     isUnsigned = True,
     generator = declareModOps,

generation/src/Multiply.hs

@@ -1,9 +1,8 @@
 {-# LANGUAGE QuasiQuotes #-}
-module Multiply
--- (
---    safeMultiplyOps
---  , unsafeMultiplyOps
---  )
+module Multiply(
+    safeMultiplyOps
+  , unsafeMultiplyOps
+  )
  where
 
 import Data.Bits((.&.))
@@ -11,7 +10,6 @@ import Data.List(foldl')
 import Data.Map.Strict(Map)
 import qualified Data.Map.Strict as Map
 import qualified Data.Set as Set
-import Gen(toLit)
 import Generators
 import Karatsuba
 import Language.Rust.Data.Ident
@@ -24,19 +22,21 @@ import System.Random(RandomGen)
 safeMultiplyOps :: RustModule
 safeMultiplyOps = RustModule {
     predicate = \ me others -> (me * 2) `elem` others,
+    suggested = \ me -> [me * 2],
     outputName = "safe_mul",
     isUnsigned = True,
     generator = declareSafeMulOperators,
-    testCase = Nothing -- Just generateSafeTest
+    testCase = Just generateSafeTest
 }
 
 unsafeMultiplyOps :: RustModule
 unsafeMultiplyOps = RustModule {
     predicate = \ _ _ -> True,
+    suggested = const [],
     outputName = "unsafe_mul",
     isUnsigned = True,
     generator = declareUnsafeMulOperators,
-    testCase = Nothing -- Just generateUnsafeTest
+    testCase = Just generateUnsafeTest
 }
 
 declareSafeMulOperators :: Word -> [Word] -> SourceFile Span

generation/src/RustModule.hs

@@ -38,6 +38,7 @@ targetTestGenerationPicos =
 
 data RustModule = RustModule {
     predicate :: Word -> [Word] -> Bool,
+    suggested :: Word -> [Word],
     outputName :: String,
     isUnsigned :: Bool,
     generator :: Word -> [Word] -> SourceFile Span,

generation/src/Scale.hs

@@ -8,7 +8,6 @@ module Scale(
 import Data.Bits((.&.))
 import Data.Map.Strict(Map)
 import qualified Data.Map.Strict as Map
-import Gen(toLit)
 import Generators
 import Language.Rust.Data.Ident
 import Language.Rust.Data.Position
@@ -20,6 +19,7 @@ import System.Random(RandomGen)
 safeScaleOps :: RustModule
 safeScaleOps = RustModule {
     predicate = \ me others -> (me + 64) `elem` others,
+    suggested = \ me -> [me + 64],
     outputName = "safe_scale",
     isUnsigned = True,
     generator = declareSafeScaleOperators,
@@ -29,6 +29,7 @@ safeScaleOps = RustModule {
 unsafeScaleOps :: RustModule
 unsafeScaleOps = RustModule {
     predicate = \ _ _ -> True,
+    suggested = const [],
     outputName = "unsafe_scale",
     isUnsigned = True,
     generator = declareUnsafeScaleOperators,

generation/src/Shift.hs

@@ -5,7 +5,6 @@ module Shift(shiftOps, signedShiftOps)
 import Data.Bits(shiftL,shiftR)
 import Data.Map.Strict(Map)
 import qualified Data.Map.Strict as Map
-import Gen(toLit)
 import Generators
 import Language.Rust.Data.Ident
 import Language.Rust.Data.Position
@@ -17,6 +16,7 @@ import System.Random(RandomGen)
 shiftOps :: RustModule
 shiftOps = RustModule {
     predicate = \ _ _ -> True,
+    suggested = const [],
     outputName = "shift",
     isUnsigned = True,
     generator = declareShiftOperators,
@@ -26,6 +26,7 @@ shiftOps = RustModule {
 signedShiftOps :: RustModule
 signedShiftOps = RustModule {
     predicate = \ _ _ -> True,
+    suggested = const [],
     outputName = "sshift",
     isUnsigned = False,
     generator = declareSignedShiftOperators,

generation/src/Signed.hs

@@ -11,6 +11,7 @@ import RustModule
 signedBaseOps :: RustModule
 signedBaseOps = RustModule {
     predicate = const (const True),
+    suggested = const [],
     outputName = "base",
     isUnsigned = False,
     generator = declareSigned,

generation/src/Subtract.hs

@@ -10,7 +10,6 @@ module Subtract(
 import Data.Bits((.&.))
 import Data.Map.Strict(Map)
 import qualified Data.Map.Strict as Map
-import Gen(toLit)
 import Generators
 import Language.Rust.Data.Ident
 import Language.Rust.Data.Position
@@ -22,6 +21,7 @@ import System.Random(RandomGen)
 safeSubtractOps :: RustModule
 safeSubtractOps = RustModule {
     predicate = \ me others -> (me + 64) `elem` others,
+    suggested = \ me -> [me + 64],
     outputName = "safe_sub",
     isUnsigned = True,
     generator = declareSafeSubtractOperators,
@@ -31,6 +31,7 @@ safeSubtractOps = RustModule {
 safeSignedSubtractOps :: RustModule
 safeSignedSubtractOps = RustModule {
     predicate = \ me others -> (me + 64) `elem` others,
+    suggested = \ me -> [me + 64],
     outputName = "safe_ssub",
     isUnsigned = False,
     generator = declareSafeSignedSubtractOperators,
@@ -40,6 +41,7 @@ safeSignedSubtractOps = RustModule {
 unsafeSubtractOps :: RustModule
 unsafeSubtractOps = RustModule {
     predicate = \ _ _ -> True,
+    suggested = const [],
     outputName = "unsafe_sub",
     isUnsigned = True,
     generator = declareUnsafeSubtractOperators,
@@ -49,6 +51,7 @@ unsafeSubtractOps = RustModule {
 unsafeSignedSubtractOps :: RustModule
 unsafeSignedSubtractOps = RustModule {
     predicate = \ _ _ -> True,
+    suggested = const [],
     outputName = "unsafe_ssub",
     isUnsigned = False,
     generator = declareUnsafeSignedSubtractOperators,