How to imitate list comprehensions for constant arrays?

Question

In Python, ['a'] * 10 generates

['a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a']

and 10 * [1,2] gives

[1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2]

How can I replicate an approximation of this infix syntax?

Update: I'm trying to use InfixNotation from Needs["Notation`"] but no luck so far.

Answer 1

The Notation package is not necessary to use an infix form of \[Star] as that is handled automatically. Also I recommend PadRight for constructing your expression (reference Generating a matrix using sublists A and B n times).

SetAttributes[Star, HoldFirst]

Star[a_List, n_Integer] := PadRight[a, n*Length@a, a]

{1, 2}⋆5    (*  ⋆ is \[Star]  *)

{1, 2, 1, 2, 1, 2, 1, 2, 1, 2}

\[Star] may be entered with EscstarEsc.

---

Performance

Let me demonstrate why I recommend PadRight instead of Sequence in ConstantArray:

foo = Range[100];
n = 250000;

ConstantArray[Unevaluated[Sequence @@ foo], n] // ByteCount // RepeatedTiming
PadRight[foo, Length[foo]*n, foo]              // ByteCount // RepeatedTiming

{1.18, 600000080}
{0.0470, 200000144}

So here PadRight is 25 times faster, and because the output is a packed array it uses one third the memory.

One may be tempted to use "Periodic" padding but unfortunately it is slower:

PadRight[foo, Length[foo]*n, "Periodic"] // ByteCount // RepeatedTiming

{0.4805, 200000144}

Still a packed array and faster than Sequence however!

Answer 2

Unevaluated@Sequence[1, 2]~ConstantArray~10

$\ $ {1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2}

Or using Notation

<< Notation`

Notation[ParsedBoxWrapper[
RowBox[{
RowBox[{"[", "const_", "]"}], "\[Star]", 
     "reps_"}]] \[DoubleLongRightArrow] ParsedBoxWrapper[
RowBox[{
RowBox[{"Unevaluated", "@", 
RowBox[{"Sequence", "[", "const_", "]"}]}], "~", "ConstantArray", "~",
      "reps_"}]]]

Now

[1, 2]\[Star]10

$\ $ {1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2}

Which displays as

---

Using InfixNotation

pythonStar[const_List, reps_Integer] := ConstantArray[Unevaluated[Sequence @@ const], reps]

InfixNotation[ParsedBoxWrapper["\[Star]"], pythonStar]

Now

{1, 2}\[Star]10

$\ $ {1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2}

Answer 3

Brief? How about this. Define:

c = ConstantArray;

Now you can get what you want using the infix notation:

"a"~c~7

and

10~c~7 

With lists

{1, 2}~c~7

you'll need to Flatten.

Answer 4

Define p for python:

a_ ~ p ~ b_List := Table[Splice[b], a]
a_ ~ p ~ b_ := Table[b, a]
10~p~{1, 2}

{1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2}

5~p~"a"

{"a", "a", "a", "a", "a"}

Answer 5

TagSetDelayed

g /: g[x__] * y_ :=
    ConstantArray[{x}, y] // Flatten
g /: y_ * g[x__] :=
    ConstantArray[{x}, y] // Flatten
g[1, 2] * 5
5 * g[1, 2]

Answer 6

There is an infix operator named Star which can be entered as esc star esc and looks exactly like the multiplication sign:

a_\[Star]b_List := Table[Splice[b], a]
a_\[Star]b_ := Table[b, a]
?Star

10 * {1, 2}

{1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2}

5 * "a"

{"a", "a", "a", "a", "a"}

Again: write the above as: 5 esc star esc "a"

Documentation

Language Guide

Operators without built-in meanings

Answer 7

Other possibilities

SubstitutionSystem[{1->1,2->2},{1,2},9] // Flatten
SubstitutionSystem[{1->2,2->1},1,19] // Flatten
(* 
   {1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2}
   {1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2}
*)

and

NestList[#&,{1,2},9]//Flatten
(* {1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2} *)