From f474639ebe6f1bc7d5ab398ae1df16af48c77708 Mon Sep 17 00:00:00 2001 From: Laurenz Date: Mon, 9 Oct 2023 16:04:10 +0200 Subject: [PATCH] Hashtag -> Hash --- README.md | 2 +- crates/typst-ide/src/complete.rs | 12 ++++++------ crates/typst-ide/src/tooltip.rs | 2 +- crates/typst-syntax/src/ast.rs | 4 ++-- crates/typst-syntax/src/highlight.rs | 12 ++++++------ crates/typst-syntax/src/kind.rs | 6 +++--- crates/typst-syntax/src/lexer.rs | 4 ++-- crates/typst-syntax/src/parser.rs | 6 +++--- crates/typst-syntax/src/reparser.rs | 4 ++-- crates/typst/src/eval/mod.rs | 2 +- crates/typst/src/geom/color.rs | 6 +++--- docs/changelog.md | 8 ++++---- docs/guides/guide-for-latex-users.md | 4 ++-- docs/reference/categories.yml | 8 ++++---- docs/reference/scripting.md | 4 ++-- docs/tutorial/1-writing.md | 6 ++++-- 16 files changed, 46 insertions(+), 44 deletions(-) diff --git a/README.md b/README.md index 3a9c75dbf..29e41be11 100644 --- a/README.md +++ b/README.md @@ -64,7 +64,7 @@ Let's dissect what's going on: select a particular symbol variant. - Now, we get to some [scripting]. To input code into a Typst document, we can - write a hashtag followed by an expression. We define two variables and a + write a hash followed by an expression. We define two variables and a recursive function to compute the n-th fibonacci number. Then, we display the results in a center-aligned table. The table function takes its cells row-by-row. Therefore, we first pass the formulas `$F_1$` to `$F_8$` and then diff --git a/crates/typst-ide/src/complete.rs b/crates/typst-ide/src/complete.rs index bb17dd37e..5da22f45e 100644 --- a/crates/typst-ide/src/complete.rs +++ b/crates/typst-ide/src/complete.rs @@ -97,7 +97,7 @@ fn complete_markup(ctx: &mut CompletionContext) -> bool { } // Start of an interpolated identifier: "#|". - if ctx.leaf.kind() == SyntaxKind::Hashtag { + if ctx.leaf.kind() == SyntaxKind::Hash { ctx.from = ctx.cursor; code_completions(ctx, true); return true; @@ -268,7 +268,7 @@ fn complete_math(ctx: &mut CompletionContext) -> bool { } // Start of an interpolated identifier: "#|". - if ctx.leaf.kind() == SyntaxKind::Hashtag { + if ctx.leaf.kind() == SyntaxKind::Hash { ctx.from = ctx.cursor; code_completions(ctx, true); return true; @@ -326,7 +326,7 @@ fn complete_field_accesses(ctx: &mut CompletionContext) -> bool { if let Some(prev) = ctx.leaf.prev_sibling(); if prev.is::(); if prev.parent_kind() != Some(SyntaxKind::Markup) || - prev.prev_sibling_kind() == Some(SyntaxKind::Hashtag); + prev.prev_sibling_kind() == Some(SyntaxKind::Hash); if let Some(value) = analyze_expr(ctx.world, &prev).into_iter().next(); then { ctx.from = ctx.cursor; @@ -796,8 +796,8 @@ fn complete_code(ctx: &mut CompletionContext) -> bool { /// Add completions for expression snippets. #[rustfmt::skip] -fn code_completions(ctx: &mut CompletionContext, hashtag: bool) { - ctx.scope_completions(true, |value| !hashtag || { +fn code_completions(ctx: &mut CompletionContext, hash: bool) { + ctx.scope_completions(true, |value| !hash || { matches!(value, Value::Symbol(_) | Value::Func(_) | Value::Type(_) | Value::Module(_)) }); @@ -933,7 +933,7 @@ fn code_completions(ctx: &mut CompletionContext, hashtag: bool) { "Creates a mapping from names to value.", ); - if !hashtag { + if !hash { ctx.snippet_completion( "function", "(${params}) => ${output}", diff --git a/crates/typst-ide/src/tooltip.rs b/crates/typst-ide/src/tooltip.rs index 37f32e222..9629462b8 100644 --- a/crates/typst-ide/src/tooltip.rs +++ b/crates/typst-ide/src/tooltip.rs @@ -49,7 +49,7 @@ fn expr_tooltip(world: &dyn World, leaf: &LinkedNode) -> Option { } let expr = ancestor.cast::()?; - if !expr.hashtag() && !matches!(expr, ast::Expr::MathIdent(_)) { + if !expr.hash() && !matches!(expr, ast::Expr::MathIdent(_)) { return None; } diff --git a/crates/typst-syntax/src/ast.rs b/crates/typst-syntax/src/ast.rs index 447903c5a..83e4ff9cf 100644 --- a/crates/typst-syntax/src/ast.rs +++ b/crates/typst-syntax/src/ast.rs @@ -339,8 +339,8 @@ impl<'a> AstNode<'a> for Expr<'a> { } impl Expr<'_> { - /// Can this expression be embedded into markup with a hashtag? - pub fn hashtag(self) -> bool { + /// Can this expression be embedded into markup with a hash? + pub fn hash(self) -> bool { matches!( self, Self::Ident(_) diff --git a/crates/typst-syntax/src/highlight.rs b/crates/typst-syntax/src/highlight.rs index e8ae613b6..b77af9224 100644 --- a/crates/typst-syntax/src/highlight.rs +++ b/crates/typst-syntax/src/highlight.rs @@ -174,7 +174,7 @@ pub fn highlight(node: &LinkedNode) -> Option { SyntaxKind::MathRoot => None, SyntaxKind::MathPrimes => None, - SyntaxKind::Hashtag => highlight_hashtag(node), + SyntaxKind::Hash => highlight_hash(node), SyntaxKind::LeftBrace => Some(Tag::Punctuation), SyntaxKind::RightBrace => Some(Tag::Punctuation), SyntaxKind::LeftBracket => Some(Tag::Punctuation), @@ -322,8 +322,8 @@ fn highlight_ident(node: &LinkedNode) -> Option { return Some(Tag::Function); } - // Are we (or an ancestor field access) directly after a hashtag. - if ancestor.prev_leaf().map(|leaf| leaf.kind()) == Some(SyntaxKind::Hashtag) { + // Are we (or an ancestor field access) directly after a hash. + if ancestor.prev_leaf().map(|leaf| leaf.kind()) == Some(SyntaxKind::Hash) { return Some(Tag::Interpolated); } @@ -339,11 +339,11 @@ fn highlight_ident(node: &LinkedNode) -> Option { None } -/// Highlight a hashtag based on context. -fn highlight_hashtag(node: &LinkedNode) -> Option { +/// Highlight a hash based on context. +fn highlight_hash(node: &LinkedNode) -> Option { let next = node.next_sibling()?; let expr = next.cast::()?; - if !expr.hashtag() { + if !expr.hash() { return None; } highlight(&next.leftmost_leaf()?) diff --git a/crates/typst-syntax/src/kind.rs b/crates/typst-syntax/src/kind.rs index 669ca0f25..40a2855d6 100644 --- a/crates/typst-syntax/src/kind.rs +++ b/crates/typst-syntax/src/kind.rs @@ -72,8 +72,8 @@ pub enum SyntaxKind { /// A root in math: `√x`, `∛x` or `∜x`. MathRoot, - /// A hashtag that switches into code mode: `#`. - Hashtag, + /// A hash that switches into code mode: `#`. + Hash, /// A left curly brace, starting a code block: `{`. LeftBrace, /// A right curly brace, terminating a code block: `}`. @@ -385,7 +385,7 @@ impl SyntaxKind { Self::MathFrac => "math fraction", Self::MathRoot => "math root", Self::MathPrimes => "math primes", - Self::Hashtag => "hashtag", + Self::Hash => "hash", Self::LeftBrace => "opening brace", Self::RightBrace => "closing brace", Self::LeftBracket => "opening bracket", diff --git a/crates/typst-syntax/src/lexer.rs b/crates/typst-syntax/src/lexer.rs index 509f5d731..18622154e 100644 --- a/crates/typst-syntax/src/lexer.rs +++ b/crates/typst-syntax/src/lexer.rs @@ -175,7 +175,7 @@ impl Lexer<'_> { '*' if !self.in_word() => SyntaxKind::Star, '_' if !self.in_word() => SyntaxKind::Underscore, - '#' => SyntaxKind::Hashtag, + '#' => SyntaxKind::Hash, '[' => SyntaxKind::LeftBracket, ']' => SyntaxKind::RightBracket, '\'' => SyntaxKind::SmartQuote, @@ -425,7 +425,7 @@ impl Lexer<'_> { '~' if self.s.eat_if('>') => SyntaxKind::Shorthand, '*' | '-' => SyntaxKind::Shorthand, - '#' => SyntaxKind::Hashtag, + '#' => SyntaxKind::Hash, '_' => SyntaxKind::Underscore, '$' => SyntaxKind::Dollar, '/' => SyntaxKind::Slash, diff --git a/crates/typst-syntax/src/parser.rs b/crates/typst-syntax/src/parser.rs index bd184b907..0cc733e6c 100644 --- a/crates/typst-syntax/src/parser.rs +++ b/crates/typst-syntax/src/parser.rs @@ -117,7 +117,7 @@ fn markup_expr(p: &mut Parser, at_start: &mut bool) { | SyntaxKind::Link | SyntaxKind::Label => p.eat(), - SyntaxKind::Hashtag => embedded_code_expr(p), + SyntaxKind::Hash => embedded_code_expr(p), SyntaxKind::Star => strong(p), SyntaxKind::Underscore => emph(p), SyntaxKind::HeadingMarker if *at_start => heading(p), @@ -254,7 +254,7 @@ fn math_expr_prec(p: &mut Parser, min_prec: usize, stop: SyntaxKind) { let m = p.marker(); let mut continuable = false; match p.current() { - SyntaxKind::Hashtag => embedded_code_expr(p), + SyntaxKind::Hash => embedded_code_expr(p), SyntaxKind::MathIdent => { continuable = true; p.eat(); @@ -595,7 +595,7 @@ fn code_expr_or_pattern(p: &mut Parser) { fn embedded_code_expr(p: &mut Parser) { p.enter_newline_mode(NewlineMode::Stop); p.enter(LexMode::Code); - p.assert(SyntaxKind::Hashtag); + p.assert(SyntaxKind::Hash); p.unskip(); let stmt = matches!( diff --git a/crates/typst-syntax/src/reparser.rs b/crates/typst-syntax/src/reparser.rs index e03e1619c..f7f89a3f6 100644 --- a/crates/typst-syntax/src/reparser.rs +++ b/crates/typst-syntax/src/reparser.rs @@ -125,8 +125,8 @@ fn try_reparse( end += 1; } - // Also take hashtag. - if start > 0 && children[start - 1].kind() == SyntaxKind::Hashtag { + // Also take hash. + if start > 0 && children[start - 1].kind() == SyntaxKind::Hash { start -= 1; } diff --git a/crates/typst/src/eval/mod.rs b/crates/typst/src/eval/mod.rs index 8627b489c..b6dbace9f 100644 --- a/crates/typst/src/eval/mod.rs +++ b/crates/typst/src/eval/mod.rs @@ -223,7 +223,7 @@ pub fn eval_string( /// In which mode to evaluate a string. #[derive(Debug, Copy, Clone, Eq, PartialEq, Hash, Cast)] pub enum EvalMode { - /// Evaluate as code, as after a hashtag. + /// Evaluate as code, as after a hash. Code, /// Evaluate as markup, like in a Typst file. Markup, diff --git a/crates/typst/src/geom/color.rs b/crates/typst/src/geom/color.rs index a5b90aa31..a6d2135f3 100644 --- a/crates/typst/src/geom/color.rs +++ b/crates/typst/src/geom/color.rs @@ -453,7 +453,7 @@ impl Color { /// The color in hexadecimal notation. /// /// Accepts three, four, six or eight hexadecimal digits and optionally - /// a leading hashtag. + /// a leading hash. /// /// If this string is given, the individual components should not be given. /// @@ -1361,11 +1361,11 @@ impl FromStr for Color { type Err = &'static str; /// Constructs a new color from hex strings like the following: - /// - `#aef` (shorthand, with leading hashtag), + /// - `#aef` (shorthand, with leading hash), /// - `7a03c2` (without alpha), /// - `abcdefff` (with alpha). /// - /// The hashtag is optional and both lower and upper case are fine. + /// The hash is optional and both lower and upper case are fine. fn from_str(hex_str: &str) -> Result { let hex_str = hex_str.strip_prefix('#').unwrap_or(hex_str); if hex_str.chars().any(|c| !c.is_ascii_hexdigit()) { diff --git a/docs/changelog.md b/docs/changelog.md index 262908753..c5f880494 100644 --- a/docs/changelog.md +++ b/docs/changelog.md @@ -888,8 +888,8 @@ description: | [Go to the announcement blog post.](https://typst.app/blog/2023/january-update) - New expression syntax in markup/math - Blocks cannot be directly embedded in markup anymore - - Like other expressions, they now require a leading hashtag - - More expressions available with hashtag, including literals (`[#"string"]`) + - Like other expressions, they now require a leading hash + - More expressions available with hash, including literals (`[#"string"]`) as well as field access and method call without space: `[#emoji.face]` - New import syntax - `[#import "module.typ"]` creates binding named `module` @@ -906,7 +906,7 @@ description: | - Symbols now listed in documentation - New `{math}` module - Contains all math-related functions - - Variables and function calls directly in math (without hashtag) access this + - Variables and function calls directly in math (without hash) access this module instead of the global scope, but can also access local variables - Can be explicitly used in code, e.g. `[#set math.vec(delim: "[")]` - Delimiter matching in math @@ -924,7 +924,7 @@ description: | - Alignment points also work for underbraces, vectors, cases, and matrices - Multiple alignment points are supported - More capable math function calls - - Function calls directly in math can now take code expressions with hashtag + - Function calls directly in math can now take code expressions with hash - They can now also take named arguments - Within math function calls, semicolons turn preceding arguments to arrays to support matrices: `[$mat(1, 2; 3, 4)$]` diff --git a/docs/guides/guide-for-latex-users.md b/docs/guides/guide-for-latex-users.md index ed3170ff5..d0fb92cb2 100644 --- a/docs/guides/guide-for-latex-users.md +++ b/docs/guides/guide-for-latex-users.md @@ -119,8 +119,8 @@ parallels programming languages like Python, providing the option to input and execute segments of code. Within Typst's markup, you can switch to code mode for a single command (or -rather, _expression_) using a hashtag (`#`). This is how you call functions to, -for example, split your project into different [files]($scripting/#modules) or +rather, _expression_) using a hash (`#`). This is how you call functions to, for +example, split your project into different [files]($scripting/#modules) or render text based on some [condition]($scripting/#conditionals). Within code mode, it is possible to include normal markup [_content_]($content) by using square brackets. Within code mode, this content is treated just as any other diff --git a/docs/reference/categories.yml b/docs/reference/categories.yml index 2c5989cee..1a4cfb921 100644 --- a/docs/reference/categories.yml +++ b/docs/reference/categories.yml @@ -20,7 +20,7 @@ math: | In math, single letters are always displayed as is. Multiple letters, however, are interpreted as variables and functions. To display multiple letters verbatim, you can place them into quotes and to access single letter - variables, you can use the [hashtag syntax]($scripting/#expressions). + variables, you can use the [hash syntax]($scripting/#expressions). ```example $ A = pi r^2 $ @@ -51,11 +51,11 @@ math: | &= (n(n+1)) / 2 $ ``` - Math mode supports special function calls without the hashtag prefix. In these + Math mode supports special function calls without the hash prefix. In these "math calls", the argument list works a little differently than in code: - Within them, Typst is still in "math mode". Thus, you can write math - directly into them, but need to use hashtag syntax to pass code expressions + directly into them, but need to use hash syntax to pass code expressions (except for strings, which are available in the math syntax). - They support positional and named arguments, but don't support trailing content blocks and argument spreading. @@ -76,7 +76,7 @@ math: | directly preceded by an identifier, so to display it verbatim in those cases, you can just insert a space before it. - Functions calls preceded by a hashtag are normal code function calls and not + Functions calls preceded by a hash are normal code function calls and not affected by these rules. All math functions are part of the `math` [module]($scripting/#modules), which diff --git a/docs/reference/scripting.md b/docs/reference/scripting.md index 3ac2b1dbd..668fe1e74 100644 --- a/docs/reference/scripting.md +++ b/docs/reference/scripting.md @@ -11,7 +11,7 @@ scripting concepts. In Typst, markup and code are fused into one. All but the most common elements are created with _functions._ To make this as convenient as possible, Typst provides compact syntax to embed a code expression into markup: An expression is -introduced with a hashtag (`#`) and normal markup parsing resumes after the +introduced with a hash (`#`) and normal markup parsing resumes after the expression is finished. If a character would continue the expression but should be interpreted as text, the expression can forcibly be ended with a semicolon (`;`). @@ -26,7 +26,7 @@ The example above shows a few of the available expressions, including [function calls]($function), [field accesses]($scripting/#fields), and [method calls]($scripting/#methods). More kinds of expressions are discussed in the remainder of this chapter. A few kinds of expressions are not -compatible with the hashtag syntax (e.g. binary operator expressions). To embed +compatible with the hash syntax (e.g. binary operator expressions). To embed these into markup, you can use parentheses, as in `[#(1 + 2)]`. ## Blocks diff --git a/docs/tutorial/1-writing.md b/docs/tutorial/1-writing.md index 6a458e442..0235032e2 100644 --- a/docs/tutorial/1-writing.md +++ b/docs/tutorial/1-writing.md @@ -120,8 +120,10 @@ default. It's also lacking a caption. Let's fix that by using the [figure]($figure) function. This function takes the figure's contents as a positional argument and an optional caption as a named argument. -Within the argument list of the `figure` function, Typst is already in code mode. This means, you can now remove the hashtag before the image function call. -The hashtag is only needed directly in markup (to disambiguate text from function calls). +Within the argument list of the `figure` function, Typst is already in code +mode. This means, you can now remove the hash before the image function call. +The hash is only needed directly in markup (to disambiguate text from function +calls). The caption consists of arbitrary markup. To give markup to a function, we enclose it in square brackets. This construct is called a _content block._