‌

Formatting

Mathematica has a number of useful formatting heads for arbitrary expressions, which fall into two main categories: spatial formatting and styling

Grid, Row, and Column

These are the primary spatial formatting heads. They primarily let you arrange lists nicely:

 Column@RandomInteger[20,20]

 Row@Riffle[RandomInteger[20,20],", "]

 Row[{20, ", ", 19, ", ", 18, ", ", 7, ", ", 0, ", ", 19, ", ", 18, 
  ", ", 19, ", ", 0, ", ", 20, ", ", 9, ", ", 3, ", ", 4, ", ", 18, 
  ", ", 11, ", ", 18, ", ", 11, ", ", 17, ", ", 15, ", ", 18}]

Grid@Array[RandomInteger[20,20]&,20]

Each of these comes with their own options and formatting rules, but the idea is the same for all of them. I’ll just point out a few things:

Anything can be part of a formatted expression:

 Grid@Array[Array[Graphics[{RandomColor[],Disk[]},ImageSizeRandomInteger[{5,20}]]&, 5] &, 5]

The internal expression is also still possible to recover using First :

 First@%

And a Grid is not just a Column of Rows :

 Row/@%//Column

Grid in particular has three special elements types that change how spacing is done, SpanFromLeft , SpanFromAbove , and SpanFromBoth . It is not always clear exactly what combination of spanning elements will achieve the desired effect, but just play around with them until the output looks right and you’ll be fine.

Be sure to look at all of the options for Grid as there are many cool things one can do. As a quick example, one can put in dividers with arbitrary coloring:

 Grid[
Array[Array[Graphics[{RandomColor[],Disk[]},ImageSizeRandomInteger[{5,20}]]&, 5] &, 5],
Dividers{Array[#->RandomColor[]&,6],Array[#->RandomColor[]&,6]}
]

Similarly look at Item because it provides more fine-grained control over grid formatting, which can often be useful.

Style, Framed, Pane, and Panel

The other class of formatting heads is the styling heads. First among them is Style which applies styling to an expression, particularly text:

Style[
	HoldForm[
	Row@{
	∫0πCos[θ]Sin[θ]ⅆθ,
	Spacer[25],
	Graphics[Disk[]]
	}
	],
	BackgroundRandomColor[],
	FontSizeLarge,
	FontColorRandomColor[],
	FontFamilyRandomChoice@$FontFamilies,
	FontVariations{"Underline" -> True,"Underlight"Purple},
	FontWeightBold,
	AutoStyleWords{
	"Cos""Text",
	"Sin""Section"
	}
	]

Essentially any styling one can apply to a Cell , one can apply to an expression using Style

Framed on the other hand does one thing. It puts a frame around an expression:

 Framed["Are you enjoying the tutorial?"]

But what makes it useful is the styling one can apply to the frame:

 Framed[
Style["Are you enjoying the tutorial?",Blue],
RoundingRadius5,
FrameStyleGrayLevel[.8],
BackgroundLightBlue]

It does nothing to affect the display of the actual expression though.

In contrast, that is all Pane does. Pane merely provides a way to change how an expression displays on screen. It’s chief use is for preventing large objects from taking up lots of display space:

 Pane[
ExampleData[{"Text","USConstitution"}],
ImageSize{500,250}
]

The display size can be variable and one can also attach scroll bars and things:

 Pane[
ExampleData[{"Text","USConstitution"}],
ImageSize{ {Automatic,500},250},
Scrollbars{False, Automatic}
]//Framed[#,FrameMargins{ {3,0},{0,0}}]&

Pane has less customization than the rest of the styling heads, but is possibly the most useful when designing quality interfaces

Panel is different from the other styling heads in that it is a sort of amalgamation of all three:

 Panel["Check this out"]

It basically generates a frame and applies default text styling, but the size of the panel can also be set:

 Panel[
ExampleData[{"Text","USConstitution"}],
ImageSize{500,250}
]

Unfortunately scrolling is disabled, so often one wraps a Pane in a Panel to achieve that:

 Panel[
Pane[
ExampleData[{"Text","USConstitution"}],
ImageSize{500,250},
Scrollbars{False, Automatic}
]
]

Panel is a nice, simple, reasonably professional looking go-to for arbitrary formatting, so it should often be the one of the first things one considers when formatting and expression

Format and Interpretation

The use for most of this formatting is often to hide the complexity of an expression. One leverages the power of the Format function and Interpretation functions to make an ugly expression look nice.

Usually one does this by defining an inert formatting head to wrap around the expression and defining the formatting for that expression:

 Format[ExampleDataFormatter[data_,title_]]:=
Interpretation[
Panel[Column[{
Style[title,Large,Bold],
Panel@Pane[
data,
ImageSize->{ {Automatic,400},150},
Scrollbars->{False, Automatic}
]},
Dividers->Center]
],
ExampleDataFormatter[data,title]
];
ExampleDataFormatter[
ExampleData[{"Text","USConstitution"}],"The United States Constitution"]

 Column@{
StringLength@First@%,
Head@%,
Last@%
}

This allows the often messy internal structure of a Mathematica expression to be hidden by a nice, content-rich format.