##
**First, Apply, Sequence, ReplaceAll**

There come times in every

*Mathematica*user's life when the all-pervasive List brackets get in the way. Sometimes it's easy to redesign the function to accept the arguments in a List. Here are other solutions.

## First

For a*single*element enclosed by brackets, you can use First to extract the element. In this example, since all

*Mathematica*arithmetic functions are Listable (they will automatically Map over a List) we specify that the argument must be an Integer so the function will fail.

**enclosed1={2};**

**Clear@function1;function1@x_Integer:=x^3;**

**function1@enclosed1**

**function1[{2}]**

**function1@First@enclosed1**

**8**

##
**Apply**

First, see if you can use Apply @@ to apply a function to the contents of your List. Apply will replace the List head with your desired function and Evaluate it.**In[107]:= Range@15**

Out[107]= {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15}

**In[108]:= Plus@@%**

Out[108]= 120

Here's a single filename that is unnecessarily surrounded by List brackets. It's a String, so we just Apply ToString to it. It then stands alone – no List brackets – but its Head is String.

**FileNames[]**

{TableFiredFibers-Control-CathodeOnly-0p644.txt}

**ToString@@%141**

TableFiredFibers-Control-CathodeOnly-0p644.txt

**Head@%**

String

**FullForm@%%**

"TableFiredFibers-Control-CathodeOnly-0p644.txt"

##
**Sequence**

Mathematica was designed as a list processing language in which the list is the fundamental data structure. Allan Newell's IPL (Information Processing Language) was the original prototype, after which John McCarthy coupled the list as a universal data structure with the lambda calculus and logic functions into the major programming language, LISP.We can Apply Sequence to a List to replace List as the container (the Head). Here are two examples, first to a single List, then to a List of Lists.

**In[115]:= Sequence@@{0,4}**

Out[115]= Sequence[0,4]

**In[119]:= Sequence@@{{0,1,1},{0,2},{0,1,3},{0,4}}**

Out[119]= Sequence[{0,1,1},{0,2},{0,1,3},{0,4}]

FileNameJoin is the safe way to assemble filepaths in Mathematica since it knows your operating system syntax. However FileNameJoin only accepts a single-level List as its argument. To feed it a nested List, use Sequence instead of List as the Head of the inner List.

**In[350]:= twoPathElements={"webPages","index.html"};**

**In[351]:= FileNameJoin@{$HomeDirectory,twoPathElements}**

Out[351]= FileNameJoin[{C:\Users\kwcarlso,{webPages,index.html}}]

Since it didn't see a List of Strings (filepath names) as the correct argument types, FileNameJoin returned the input. Using Sequence solves this.

**In[352]:= twoPathElements=Sequence["webPages","index.html"];**

**In[353]:= FileNameJoin@{$HomeDirectory,twoPathElements}**

Out[353]= C:\Users\kwcarlso\webPages\index.html

The context of one function I use to illustrate Sequence is worth mentioning (but skip this to get to more usages of Sequence). I have digitally sampled a curve from the literature (a paper by Holsheimer from 1999) in the graphing program Origin. In other words, you can import an image, in this case a graph for which Holsheimer doesn't give either the underlying data or an equation, and repeatedly click on it to harvest {x,y} values. We captured 163 sample points on the solid curve below, which is a vast improvement on the antiquated method of using a straightedge to pick up x and y values off the axes.

With that many sample points, finding the x value closest to the one desired is a reasonable alternative to fitting a curve and applying the fit equation to values you wish to interpolate or extrapolate.

So this is a function to find the nearest x value (a neuron axon diameter, fiberDiameter) to one for which we want to know the threshold as determined by Holsheimer (which is the y-value retrieved). The problem is Nearest returns values in List brackets, which don't match the un-bracketed x values in the List of data. Applying Sequence to the result of Nearest feeds the unbracketed value to Cases, which then performs the match.

Clear@diameterThreshold; diameterThreshold[fiberDiameter_, fiberThresholdSourceData_:holsheimerData1999] := Cases[fiberThresholdSourceData, {x_, y_} /; x == Sequence@@Nearest[fiberThresholdSourceData[[All, 1]], fiberDiameter] ]

So in sum this function says: Clear the function name (which I do habitually at the start of a function definition to prevent accidentally testing a previous version as I revise it). Then define it as the Cases in the source data file (fiberThresholdSourceData--default to the holsheimerData1999 file unless I specify another file) such that ( /; ) the x-value is Nearest to the fiberDiameter parameter I give it.

##
**ReplaceAll**

Here is a third way using rule patterns.**In[128]:= {{0,1,1},{0,2},{0,1,3},{0,4}}/. List[a__] ->a**

Out[128]= Sequence[{0,1,1},{0,2},{0,1,3},{0,4}]