Wolfram Language & System Documentation Center

Thread[f[args]]

"threads" f over any lists that appear in args.

Thread[f[args],h]

threads f over any objects with head h that appear in args.

Thread[f[args],h,n]

threads f over objects with head h that appear in the first n args.

Details
Details and Options Details and Options
Examples  
Basic Examples  
Scope  
Sequence Specifications  
Head Specification  
Generalizations & Extensions  
Applications  
Properties & Relations  
Possible Issues  
See Also
Tech Notes
Related Guides
Related Links
History
Cite this Page

Thread

Thread[f[args]]

"threads" f over any lists that appear in args.

Thread[f[args],h]

threads f over any objects with head h that appear in args.

Thread[f[args],h,n]

threads f over objects with head h that appear in the first n args.

Details

  • Functions with attribute Listable are automatically threaded over lists.
  • All the elements in the specified args whose heads are h must be of the same length.
  • Arguments that do not have head h are copied as many times as there are elements in the arguments that do have head h. »
  • Thread specifies arguments using the standard sequence specification:
  • Allall elements
    Noneno elements
    nelements 1 through n
    -nlast n elements
    {n}element n only
    {m,n}elements m through n inclusive
    {m,n,s}elements m through n in steps of s

Examples

open all close all

Basic Examples  (3)

Wolfram Language code: Thread[f[{a, b, c}]]
Wolfram Language code: Thread[f[{a, b, c}, x]]
Wolfram Language code: Thread[f[{a, b, c}, {x, y, z}]]

Convert equations for lists to lists of equations:

Wolfram Language code: Thread[{a, b, c} == {x, y, z}]

Apply a function to both sides of an equation:

Wolfram Language code: Thread[Log[x == y], Equal]

Scope  (9)

Sequence Specifications  (7)

By default, thread over all arguments:

Wolfram Language code: Thread[f[{a, b}, {r, s}, {u, v}, {x, y}], List]
Wolfram Language code: Thread[f[{a, b}, {r, s}, {u, v}, {x, y}], List, All]

Do not thread at all:

Wolfram Language code: Thread[f[{a, b}, {r, s}, {u, v}, {x, y}], List, None]

Thread over the first two arguments only:

Wolfram Language code: Thread[f[{a, b}, {r, s}, {u, v}, {x, y}], List, 2]

Thread over the last two arguments only:

Wolfram Language code: Thread[f[{a, b}, {r, s}, {u, v}, {x, y}], List, -2]

Thread over argument 2 only:

Wolfram Language code: Thread[f[{a, b}, {r, s}, {u, v}, {x, y}], List, {2}]

Thread over arguments 2 through 4:

Wolfram Language code: Thread[f[{a, b}, {r, s}, {u, v}, {x, y}], List, {2, 4}]

Thread over every other argument:

Wolfram Language code: Thread[f[{a, b}, {r, s}, {u, v}, {x, y}], List, {1, -1, 2}]

Head Specification  (2)

By default, thread over lists:

Wolfram Language code: Thread[f[{a, b}, {c, d}]]
Wolfram Language code: Thread[f[{a, b}, {c, d}], List]

By default, does not thread over heads other than List:

Wolfram Language code: Thread[f[a + b, c + d]]

Thread with respect to Plus:

Wolfram Language code: Thread[f[a + b, c + d], Plus]

Generalizations & Extensions  (1)

Elements that are not lists are repeated:

Wolfram Language code: Thread[f[{a, b, c}, h, {x, y, z}]]

The repetition of non-lists also occurs in functions with attribute Listable:

Wolfram Language code: {1, 2, 3} ^ 2 === {1 ^ 2, 2 ^ 2, 3 ^ 2}
Wolfram Language code: Attributes[Power]

Applications  (3)

Build a list of rules:

Wolfram Language code: Thread[{a, b, c} -> {1, 2, 3}]

Equate coefficients in a polynomial equation:

Wolfram Language code: CoefficientList[#, x]& /@ (1 + 2x + 3x ^ 2 == a + b x + c x ^ 2)
Wolfram Language code: Thread[%]

Alternatively, use SolveAlways:

Wolfram Language code: SolveAlways[1 + 2x + 3x ^ 2 == a + b x + c x ^ 2, x]

Form pairs with a constant second element:

Wolfram Language code: Thread[{{a, b, c}, 0}]

Properties & Relations  (3)

Functions with attribute Listable are threaded automatically over lists:

Wolfram Language code: Sqrt[{1, 2, 3, 4}]
Wolfram Language code: {1, 2, 3, 4} + 1
Wolfram Language code: {1, 2, 3, 4} + {a, b, c, d}

MapThread works like Thread, but takes the function and arguments separately:

Wolfram Language code: MapThread[f, {{a, b, c}, {x, y, z}}]
Wolfram Language code: Thread[f[{a, b, c}, {x, y, z}]]

The function to thread over can be List as well:

Wolfram Language code: Thread[{{a, b, c}, {x, y, z}}]

In this case, the result is the same as a transposition:

Wolfram Language code: Transpose[{{a, b, c}, {x, y, z}}]

Possible Issues  (1)

Thread evaluates the whole expression before threading:

Wolfram Language code: Thread[D[{x, x y, x z}, {x, y, z}]]

MapThread takes the function and its arguments separately:

Wolfram Language code: MapThread[D, {{x, x y, x z}, {x, y, z}}]

Suppressing evaluation has a similar effect:

Wolfram Language code: Thread[Unevaluated[D[{x, x y, x z}, {x, y, z}]]]
Wolfram Research (1988), Thread, Wolfram Language function, https://reference.wolfram.com/language/ref/Thread.html.

Text

Wolfram Research (1988), Thread, Wolfram Language function, https://reference.wolfram.com/language/ref/Thread.html.

CMS

Wolfram Language. 1988. "Thread." Wolfram Language & System Documentation Center. Wolfram Research. https://reference.wolfram.com/language/ref/Thread.html.

APA

Wolfram Language. (1988). Thread. Wolfram Language & System Documentation Center. Retrieved from https://reference.wolfram.com/language/ref/Thread.html

BibTeX

@misc{reference.wolfram_2026_thread, author="Wolfram Research", title="{Thread}", year="1988", howpublished="\url{https://reference.wolfram.com/language/ref/Thread.html}", note=[Accessed: 01-September-2026]}

BibLaTeX

@online{reference.wolfram_2026_thread, organization={Wolfram Research}, title={Thread}, year={1988}, url={https://reference.wolfram.com/language/ref/Thread.html}, note=[Accessed: 01-September-2026]}