Merge #105: Fix sampling

e7d7cac fix: Point mdbook to correct book location (Christian Lewe)
90963f6 fix: Separate Identifier and AliasName (Christian Lewe)
436f610 fix: Grammar (Christian Lewe)
03c1425 fix: Avoid reserved function names during sampling (Christian Lewe)

Pull request description:

  Fixes #104

ACKs for top commit:
  apoelstra:
    ACK e7d7cac; successfully ran local tests

Tree-SHA512: f483e9b4cdc1d1223254e5f41221d2b9d99ec2c2990181cb9b229bcafdbf3fb8bb190ce3020809caaaea15be62ff0c909d97905ee5a371c1600e0a98ca468a4c

Author: apoelstra

.github/workflows/book.yml

@@ -21,7 +21,7 @@ jobs:
 
     - name: Build website
       run: |
-        nix develop .#book --command bash -c "mdbook build"
+        nix develop .#book --command bash -c "mdbook build book"
 
     - name: Deploy to GitHub pages
       uses: JamesIves/github-pages-deploy-action@v4

src/ast.rs

@@ -12,7 +12,7 @@ use crate::error::{Error, RichError, Span, WithSpan};
 use crate::num::{NonZeroPow2Usize, Pow2Usize};
 use crate::parse::MatchPattern;
 use crate::pattern::Pattern;
-use crate::str::{FunctionName, Identifier, ModuleName, WitnessName};
+use crate::str::{AliasName, FunctionName, Identifier, ModuleName, WitnessName};
 use crate::types::{
     AliasedType, ResolvedType, StructuralType, TypeConstructible, TypeDeconstructible, UIntType,
 };
@@ -485,7 +485,7 @@ impl<'a> TreeLike for ExprTree<'a> {
 #[derive(Clone, Debug, Eq, PartialEq, Default)]
 struct Scope {
     variables: Vec<HashMap<Identifier, ResolvedType>>,
-    aliases: HashMap<Identifier, ResolvedType>,
+    aliases: HashMap<AliasName, ResolvedType>,
     parameters: HashMap<WitnessName, ResolvedType>,
     witnesses: HashMap<WitnessName, ResolvedType>,
     functions: HashMap<FunctionName, CustomFunction>,
@@ -569,7 +569,7 @@ impl Scope {
     /// There are any undefined aliases.
     pub fn resolve(&self, ty: &AliasedType) -> Result<ResolvedType, Error> {
         let get_alias =
-            |name: &Identifier| -> Option<ResolvedType> { self.aliases.get(name).cloned() };
+            |name: &AliasName| -> Option<ResolvedType> { self.aliases.get(name).cloned() };
         ty.resolve(get_alias).map_err(Error::UndefinedAlias)
     }
 
@@ -578,9 +578,9 @@ impl Scope {
     /// ## Errors
     ///
     /// There are any undefined aliases.
-    pub fn insert_alias(&mut self, alias: Identifier, ty: AliasedType) -> Result<(), Error> {
+    pub fn insert_alias(&mut self, name: AliasName, ty: AliasedType) -> Result<(), Error> {
         let resolved_ty = self.resolve(&ty)?;
-        self.aliases.insert(alias, resolved_ty);
+        self.aliases.insert(name, resolved_ty);
         Ok(())
     }
 
@@ -1082,7 +1082,7 @@ impl AbstractSyntaxTree for Call {
                 let args_tys = crate::jet::source_type(jet)
                     .iter()
                     .map(AliasedType::resolve_builtin)
-                    .collect::<Result<Vec<ResolvedType>, Identifier>>()
+                    .collect::<Result<Vec<ResolvedType>, AliasName>>()
                     .map_err(Error::UndefinedAlias)
                     .with_span(from)?;
                 check_argument_types(from.args(), &args_tys).with_span(from)?;

src/error.rs

@@ -6,7 +6,7 @@ use simplicity::hashes::{sha256, Hash, HashEngine};
 use simplicity::{elements, Cmr};
 
 use crate::parse::{MatchPattern, Rule};
-use crate::str::{FunctionName, Identifier, JetName, ModuleName, WitnessName};
+use crate::str::{AliasName, FunctionName, Identifier, JetName, ModuleName, WitnessName};
 use crate::types::{ResolvedType, UIntType};
 
 /// Position of an object inside a file.
@@ -323,7 +323,7 @@ pub enum Error {
     ExpressionNotConstant,
     IntegerOutOfBounds(UIntType),
     UndefinedVariable(Identifier),
-    UndefinedAlias(Identifier),
+    UndefinedAlias(AliasName),
     VariableReuseInPattern(Identifier),
     WitnessReused(WitnessName),
     WitnessTypeMismatch(WitnessName, ResolvedType, ResolvedType),

src/minimal.pest

@@ -7,12 +7,12 @@ statement         =  { assignment | expression }
 expression        =  { block_expression | single_expression }
 block_expression  =  { "{" ~ (statement ~ ";")* ~ expression? ~ "}" }
 
-identifier        = @{ !builtin_type ~ ASCII_ALPHA ~ (ASCII_ALPHANUMERIC | "_")* }
+identifier        = @{ ASCII_ALPHA ~ (ASCII_ALPHANUMERIC | "_")* }
 jet               = @{ "jet::" ~ (ASCII_ALPHANUMERIC | "_")+ }
-witness_name      = @{ (ASCII_ALPHANUMERIC | "_")+ }
+witness_name      = @{ ASCII_ALPHA ~ (ASCII_ALPHANUMERIC | "_")* }
 builtin_type      = @{ ("Either" | "Option" | "bool" | "List" | unsigned_type) ~ !ASCII_ALPHANUMERIC }
 
-builtin_function  = @{ (jet | "unwrap_left" | "unwrap_right" | "for_while" | "is_none" | "unwrap" | "assert" | "panic" | "match" | "into" | "fold" | "dbg") ~ !ASCII_ALPHANUMERIC }
+builtin_function  = @{ ("unwrap_left" | "unwrap_right" | "for_while" | "is_none" | "unwrap" | "assert" | "panic" | "match" | "into" | "fold" | "dbg") ~ !ASCII_ALPHANUMERIC }
 function_name     =  { !builtin_function ~ identifier }
 typed_identifier  =  { identifier ~ ":" ~ ty }
 function_params   =  { "(" ~ (typed_identifier ~ ("," ~ typed_identifier)*)? ~ ")" }
@@ -47,7 +47,7 @@ list_bound        = @{ ASCII_DIGIT+ }
 list_type         =  { "List<" ~ ty ~ "," ~ list_bound ~ ">" }
 ty                =  { alias_name | builtin_alias | sum_type | option_type | boolean_type | unsigned_type | tuple_type | array_type | list_type }
 builtin_alias     = @{ "Ctx8" | "Pubkey" | "Message64" | "Message" | "Signature" | "Scalar" | "Fe" | "Gej" | "Ge" | "Point" | "Height" | "Time" | "Distance" | "Duration" | "Lock" | "Outpoint" | "Confidential1" | "ExplicitAsset" | "Asset1" | "ExplicitAmount" | "Amount1" | "ExplicitNonce" | "Nonce" | "TokenAmount1" }
-alias_name        =  { !builtin_alias ~ identifier }
+alias_name        =  { !builtin_type ~ !builtin_alias ~ identifier }
 type_keyword      = @{ "type" ~ !ASCII_ALPHANUMERIC }
 type_alias        =  { type_keyword ~ alias_name ~ "=" ~ ty ~ ";" }
 

src/parse.rs

@@ -16,7 +16,8 @@ use crate::impl_eq_hash;
 use crate::num::NonZeroPow2Usize;
 use crate::pattern::Pattern;
 use crate::str::{
-    Binary, Decimal, FunctionName, Hexadecimal, Identifier, JetName, ModuleName, WitnessName,
+    AliasName, Binary, Decimal, FunctionName, Hexadecimal, Identifier, JetName, ModuleName,
+    WitnessName,
 };
 use crate::types::{AliasedType, BuiltinAlias, TypeConstructible, UIntType};
 
@@ -201,14 +202,14 @@ pub enum CallName {
 #[derive(Clone, Debug)]
 #[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
 pub struct TypeAlias {
-    name: Identifier,
+    name: AliasName,
     ty: AliasedType,
     span: Span,
 }
 
 impl TypeAlias {
     /// Access the name of the alias.
-    pub fn name(&self) -> &Identifier {
+    pub fn name(&self) -> &AliasName {
         &self.name
     }
 
@@ -809,6 +810,7 @@ macro_rules! impl_parse_wrapped_string {
 impl_parse_wrapped_string!(FunctionName, function_name);
 impl_parse_wrapped_string!(Identifier, identifier);
 impl_parse_wrapped_string!(WitnessName, witness_name);
+impl_parse_wrapped_string!(AliasName, alias_name);
 impl_parse_wrapped_string!(ModuleName, module_name);
 
 /// Copy of [`FromStr`] that internally uses the PEST parser.
@@ -1064,7 +1066,7 @@ impl PestParse for TypeAlias {
         let span = Span::from(&pair);
         let mut it = pair.into_inner();
         let _type_keyword = it.next().unwrap();
-        let name = Identifier::parse(it.next().unwrap().into_inner().next().unwrap())?;
+        let name = AliasName::parse(it.next().unwrap())?;
         let ty = AliasedType::parse(it.next().unwrap())?;
         Ok(Self { name, ty, span })
     }
@@ -1329,9 +1331,8 @@ impl PestParse for AliasedType {
         for data in pair.post_order_iter() {
             match data.node.0.as_rule() {
                 Rule::alias_name => {
-                    let pair = data.node.0.into_inner().next().unwrap();
-                    let identifier = Identifier::parse(pair)?;
-                    output.push(Item::Type(AliasedType::alias(identifier)));
+                    let name = AliasName::parse(data.node.0)?;
+                    output.push(Item::Type(AliasedType::alias(name)));
                 }
                 Rule::builtin_alias => {
                     let builtin = BuiltinAlias::parse(data.node.0)?;

src/str.rs

@@ -79,7 +79,37 @@ impl FunctionName {
 }
 
 wrapped_string!(FunctionName, "function name");
-impl_arbitrary_lowercase_alpha!(FunctionName);
+
+#[cfg(feature = "arbitrary")]
+impl<'a> arbitrary::Arbitrary<'a> for FunctionName {
+    fn arbitrary(u: &mut arbitrary::Unstructured<'a>) -> arbitrary::Result<Self> {
+        const RESERVED_NAMES: [&str; 11] = [
+            "unwrap_left",
+            "unwrap_right",
+            "for_while",
+            "is_none",
+            "unwrap",
+            "assert",
+            "panic",
+            "match",
+            "into",
+            "fold",
+            "dbg",
+        ];
+
+        let len = u.int_in_range(1..=10)?;
+        let mut string = String::with_capacity(len);
+        for _ in 0..len {
+            let offset = u.int_in_range(0..=25)?;
+            string.push((b'a' + offset) as char)
+        }
+        if RESERVED_NAMES.contains(&string.as_str()) {
+            string.push('_');
+        }
+
+        Ok(Self::from_str_unchecked(string.as_str()))
+    }
+}
 
 /// The identifier of a variable.
 #[derive(Clone, Ord, PartialOrd, Eq, PartialEq, Hash)]
@@ -111,6 +141,69 @@ impl<'a> arbitrary::Arbitrary<'a> for JetName {
     }
 }
 
+/// The name of a type alias.
+#[derive(Clone, Ord, PartialOrd, Eq, PartialEq, Hash)]
+pub struct AliasName(Arc<str>);
+
+wrapped_string!(AliasName, "name of a type alias");
+
+#[cfg(feature = "arbitrary")]
+impl<'a> arbitrary::Arbitrary<'a> for AliasName {
+    fn arbitrary(u: &mut arbitrary::Unstructured<'a>) -> arbitrary::Result<Self> {
+        const RESERVED_NAMES: [&str; 37] = [
+            "Either",
+            "Option",
+            "bool",
+            "List",
+            "u128",
+            "u256",
+            "u16",
+            "u32",
+            "u64",
+            "u1",
+            "u2",
+            "u4",
+            "u8",
+            "Ctx8",
+            "Pubkey",
+            "Message64",
+            "Message",
+            "Signature",
+            "Scalar",
+            "Fe",
+            "Gej",
+            "Ge",
+            "Point",
+            "Height",
+            "Time",
+            "Distance",
+            "Duration",
+            "Lock",
+            "Outpoint",
+            "Confidential1",
+            "ExplicitAsset",
+            "Asset1",
+            "ExplicitAmount",
+            "Amount1",
+            "ExplicitNonce",
+            "Nonce",
+            "TokenAmount1",
+        ];
+
+        let len = u.int_in_range(1..=10)?;
+        let mut string = String::with_capacity(len);
+        for _ in 0..len {
+            let offset = u.int_in_range(0..=25)?;
+            string.push((b'a' + offset) as char)
+        }
+        if RESERVED_NAMES.contains(&string.as_str()) {
+            string.push('_');
+        }
+
+        Ok(Self::from_str_unchecked(string.as_str()))
+    }
+}
+
 /// A string of decimal digits.
 #[derive(Clone, Ord, PartialOrd, Eq, PartialEq, Hash)]
 pub struct Decimal(Arc<str>);

src/types.rs

@@ -7,7 +7,7 @@ use simplicity::types::{CompleteBound, Final};
 
 use crate::array::{BTreeSlice, Partition};
 use crate::num::{NonZeroPow2Usize, Pow2Usize};
-use crate::str::Identifier;
+use crate::str::AliasName;
 
 /// Primitives of the Simfony type system, excluding type aliases.
 #[derive(Debug, PartialEq, Eq, Hash, Clone)]
@@ -494,7 +494,7 @@ pub struct AliasedType(AliasedInner);
 #[derive(Debug, PartialEq, Eq, Hash, Clone)]
 enum AliasedInner {
     /// Type alias.
-    Alias(Identifier),
+    Alias(AliasName),
     /// Builtin type alias.
     Builtin(BuiltinAlias),
     /// Type primitive.
@@ -533,9 +533,9 @@ pub enum BuiltinAlias {
 
 impl AliasedType {
     /// Access a user-defined alias.
-    pub const fn as_alias(&self) -> Option<&Identifier> {
+    pub const fn as_alias(&self) -> Option<&AliasName> {
         match &self.0 {
-            AliasedInner::Alias(identifier) => Some(identifier),
+            AliasedInner::Alias(name) => Some(name),
             _ => None,
         }
     }
@@ -549,8 +549,8 @@ impl AliasedType {
     }
 
     /// Create a type alias from the given `identifier`.
-    pub const fn alias(identifier: Identifier) -> Self {
-        Self(AliasedInner::Alias(identifier))
+    pub const fn alias(name: AliasName) -> Self {
+        Self(AliasedInner::Alias(name))
     }
 
     /// Create a builtin type alias.
@@ -559,15 +559,15 @@ impl AliasedType {
     }
 
     /// Resolve all aliases in the type based on the given map of `aliases` to types.
-    pub fn resolve<F>(&self, mut get_alias: F) -> Result<ResolvedType, Identifier>
+    pub fn resolve<F>(&self, mut get_alias: F) -> Result<ResolvedType, AliasName>
     where
-        F: FnMut(&Identifier) -> Option<ResolvedType>,
+        F: FnMut(&AliasName) -> Option<ResolvedType>,
     {
         let mut output = vec![];
         for data in self.post_order_iter() {
             match &data.node.0 {
-                AliasedInner::Alias(alias) => {
-                    let resolved = get_alias(alias).ok_or(alias.clone())?;
+                AliasedInner::Alias(name) => {
+                    let resolved = get_alias(name).ok_or(name.clone())?;
                     output.push(resolved);
                 }
                 AliasedInner::Builtin(builtin) => {
@@ -608,7 +608,7 @@ impl AliasedType {
     }
 
     /// Resolve all aliases in the type based on the builtin type aliases only.
-    pub fn resolve_builtin(&self) -> Result<ResolvedType, Identifier> {
+    pub fn resolve_builtin(&self) -> Result<ResolvedType, AliasName> {
         self.resolve(|_| None)
     }
 }
@@ -741,8 +741,8 @@ impl From<UIntType> for AliasedType {
     }
 }
 
-impl From<Identifier> for AliasedType {
-    fn from(value: Identifier) -> Self {
+impl From<AliasName> for AliasedType {
+    fn from(value: AliasName) -> Self {
         Self::alias(value)
     }
 }
@@ -760,14 +760,14 @@ impl crate::ArbitraryRec for AliasedType {
 
         match budget.checked_sub(1) {
             None => match u.int_in_range(0..=3)? {
-                0 => Identifier::arbitrary(u).map(Self::alias),
+                0 => AliasName::arbitrary(u).map(Self::alias),
                 1 => BuiltinAlias::arbitrary(u).map(Self::builtin),
                 2 => Ok(Self::boolean()),
                 3 => UIntType::arbitrary(u).map(Self::from),
                 _ => unreachable!(),
             },
             Some(new_budget) => match u.int_in_range(0..=8)? {
-                0 => Identifier::arbitrary(u).map(Self::alias),
+                0 => AliasName::arbitrary(u).map(Self::alias),
                 1 => BuiltinAlias::arbitrary(u).map(Self::builtin),
                 2 => Ok(Self::boolean()),
                 3 => UIntType::arbitrary(u).map(Self::from),