Combining \newunicodechar with delimiter sizes \big, \left, \right, etc

Question

\documentclass[11pt]{standalone}
\usepackage[utf8]{inputenc}
\usepackage{newunicodechar}
\newunicodechar{‖}{\ensuremath{\|}}
\begin{document}
$$ ‖x‖ $$
$$ \big‖x\big‖ $$  % Error: Missing delimiter
\end{document}

Can we somehow hack \big to make it work?

Answer 1

Using \ensuremath makes no sense.

You can make it work with pdflatex, but you have to use braces with \big or similar commands. Not with \left and \right.

\documentclass{article}
\usepackage{amsmath}
\usepackage{newunicodechar}
\newunicodechar{‖}{\|}
\begin{document}
[
‖x‖ + \bigl{‖}x\bigr{‖} + \left‖\frac{x}{2}\right‖
]
\end{document}

The problem is that ‖ is not a single byte and \bigl only absorbs the first one.

Usual caveats. $$ should not be used in LaTeX and \big is not the right command for that use case.

On the other hand, \lVert and \rVert are the right commands for that use case.

Answer 2

For "academical" purpose, this is a macro that automatically braces the next Unicode character.

It does requires patching \big however. Unavoidably.

How TeX input stream works is a bit complex, you still need TeX knowledge to use this macro i.e. it's not 100% automatic.

It only works in pdflatex -- nevertheless if you're using some Unicode engine you would not need this code at all.

Side note--if you use this in a package/extend the code etc., fix the naming convention of \__stored_content etc. yourself, see expl3 manual interface3.pdf.

(use \tl_analysis_map_inline:nn just to check if it's an active character instead of something like e.g. \str_count:n, to handle some unlikely case that there's a length-1 control sequence and \escapechar=-1...)

%! TEX program = pdflatex
\documentclass{article}
\usepackage{newunicodechar}
\errorcontextlines=100
\newunicodechar{‖}{\ensuremath{\|}}
\begin{document}
\ExplSyntaxOn
% command docs:
% if you execute \__brace_next_unicode:nw {blob blob} ■ where ■ is any
% multi-byte UTF8 character, after some execution steps blob blob {■}
% will be executed. (spaces are only for demonstration.)
\cs_new_protected:Npn __brace_next_unicode:nw #1 {
 \peek_N_type:TF {
  \tl_set:Nn __stored_content {#1}  % actually this part can be done expandably
        % as well... but \peek_N_type:TF is already unexpandable
  __brace_next_unicode_get_one_byte:N
 }
 {
  % do nothing, just put blob blob out
  #1
 }
}
\cs_new_protected:Npn __brace_next_unicode_get_one_byte:N #1 {
 \tl_analysis_map_inline:nn {#1} {
  \bool_set:Nn __is_active_character { \token_if_eq_charcode_p:NN ##3 D }
 }
 \bool_if:nTF __is_active_character {
  \int_compare:nNnTF {#1} &lt; {&quot;80} { % not a part of multibyte UTF8 character, put it back. \__stored_content #1 } { % part of multibyte UTF8 character. \int_compare:nNnTF {#1} < {"E0} {
    % 2 bytes
    __brace_next_unicode_handle_two:nn #1
   } {
    \int_compare:nNnTF {`#1} < {"F0} {
     % 3 bytes
     __brace_next_unicode_handle_three:nnn #1
    } {
     % 4 bytes
     __brace_next_unicode_handle_four:nnnn #1
    }
   }
  }
 }
 {
  % else, it could be a control sequence or similar. Do nothing with it.
  __stored_content #1
 }
}
\cs_new_protected:Npn __brace_next_unicode_handle_two:nn #1 #2 {
 __stored_content {#1 #2}
}
\cs_new_protected:Npn __brace_next_unicode_handle_three:nnn #1 #2 #3 {
 __stored_content {#1 #2 #3}
}
\cs_new_protected:Npn __brace_next_unicode_handle_four:nnnn #1 #2 #3 #4 {
 __stored_content {#1 #2 #3 #4}
}
%__brace_next_unicode:nw {\pretty:nn {123}} ■
\NewCommandCopy \oldbig \big
\def \big {__brace_next_unicode:nw {\oldbig}}
\ExplSyntaxOff
[ ‖x‖ ]
[ \big‖x\big‖ ]
% check that it still works in normal cases
[ \big|x\big| ]
[ \big|x\big| ]
[ \big{|}x\big{|} ]
[ \big{|}x\big{|} ]
[ \big\lbrace x\big\rbrace ]
\end{document}