# Vocabulary/curlylfdot

>>
<< ` `
Down to: Dyad ` `
Back to: Vocabulary
Thru to: Dictionary

`{. y`Head

Rank Infinity *-- operates on x and y as a whole, by items of y --*
WHY IS THIS IMPORTANT?

The leading item of `y`

{. 'abc' a

### Common uses

1. Convert a single-item list `y` into an atom

'a' -: {. ,'a' 1

2. More generally, take the first item of array `y`, producing an array of lower rank.

]z =: i. 3 4 0 1 2 3 4 5 6 7 8 9 10 11 {. z 0 1 2 3

3. When applied on a list, e.g. the rows of a table, take the first atom on each row

{."1 z 0 4 8

### Related Primitives

Behead (`}. y`),
Tail (`{: y`),
Curtail (`}: y`)

### More Information

1. Unless `y` is an atom, the rank of `{. y` is 1 less than the rank of `y`.
This is different from `1{.y` which is a list of items of `y` (and therefore has the same rank as `y` unless `y` is an atom).

(`{. y`) is equivalent to (`0 { 1 {. y`)

]z =: i. 3 4 0 1 2 3 4 5 6 7 8 9 10 11 {. z 0 1 2 3 1 {. z NB. they look the same... 0 1 2 3 $ {. z 4 $ 1 {. z NB. ...but they have different shapes 1 4

2. If `y` has no items, `{. y` produces an item of fill atoms.
`{.!.f` sets the fill atom, which by default is the fill appropriate for the type of `y`.

`y` has no items but each of the (nonexistent) items can have a shape. The result is a noun with that shape made up of fill atoms.

{. 0 $ a: ++ || ++ {. 0 $ 0 0 {.!.'b' 0 $ 0 b i. 0 3 4 NB. 0 items, each of shape 3 4 {. i. 0 3 4 NB. create an item of fills 0 0 0 0 0 0 0 0 0 0 0 0 {. i. 0 0 4 NB. The item has shape 0 4 $ {. i. 0 0 4 0 4

### Use These Combinations

Combinations using `{. y` that have exceptionally good performance include:

**What it does****Type;**

**Precisions;**

Ranks**Syntax****Variants;**

**Restrictions****Benefits;**

**Bug Warnings**Apply dyads to infixes (or entire axes) of length 2 `2 f/\ y`fastest way to apply `f`when there are 2 items (faster than`({. f {:)`)Count number of equal items per partition, and one copy of the item list `x (#,{.)/. y`also `({.,#)`avoids building argument cells of `y`

`x {. y`Take

Rank 1 _ *-- operates on lists of x and the entirety of y --*
WHY IS THIS IMPORTANT?

The leading `x` items of `y`.

...the *trailing* `x` items, if `x` is negative.

2 {. 'abcde' ab _2 {. 'abcde' de

### Common uses

1. Convert a list to a fixed size

6 {. 3 1 4 1 5 9 6 2 3 5 3 1 4 1 5 9 6 {. 3 1 4 3 1 4 0 0 0

2. (With Drop `}.`)
Chop out an interval from a list

C/f `MID$` in BASIC, `substr()` in other languages

az=: 'abcdefghijklmnopqrstuvwxyz' 3 {. 5 }. az fgh

Subarray `];.0` is a better way to do this.

3. (With Drop `}.`)
Split a list into beginning and ending sections

split NB. defined in stdlib {. ,&< }. lst=: 'abcde' 2 split lst +--+---+ |ab|cde| +--+---+ 'hd lst'=: split lst hd ; lst +-+----+ |a|bcde| +-+----+

`split` is a

- Standard Library word(s) residing in the 'z'-locale.
- Defined in the factory script
`stdlib.ijs`. - View definition(s) by entering in the J session:
`open'stdlib'`

### Related Primitives

Drop (`x }. y`)

### More Information

1. An `x` greater than `#y` specifies an overtake: the result will have `x` items,
with the items past `#y` containing fill atoms.
`{.!.f` sets the fill atom, which by default is the fill appropriate for the type of `y`.

_5 {. 'abc' NB. Overtake: result is 5 atoms, with blank fill abc _5 {.!.'*' 'abc' NB. Changed fill atom **abc ]a =: i. 2 4 0 1 2 3 4 5 6 7 3 {. a NB. result has 3 items, filled 0 1 2 3 4 5 6 7 0 0 0 0

2. If `x` is a list, each atom of `x` specifies a *take* operation along the corresponding axis of `y`.

]a =: _4 ]\ 'abcdefghijkl' abcd efgh ijkl _4 2 {.!.'*' a NB. overtake the first axis, and take 1st two atoms in each row ** ab ef ij

### Details

1. An atom of `x` equal to `_` or `__` specifies that the corresponding axis is to be *taken in full*.

_ 2 {. a NB. Take all rows, and 1st 2 atoms in each row ab ef ij

2. When `x` is a list, axes of `y` beyond the length of `x` are taken in full.

3. If `y` is an array, `x` must not be longer than the rank of `y`.

2 3 {. i. 4 |length error

4. If `y` is an atom, leading axes of length 1 are added as needed to bring its rank up to the same as the length of `x`,
and then the *take* operations are applied.

5. If `x` is empty, `x {. y` is the same as `y`.
This is the only way that the result of `x {. y` can be an atom.

### Use These Combinations

Combinations using ` x{. y` that have exceptionally good performance include:

**What it does****Type;**

**Precisions;**

Ranks**Syntax****Variants;**

**Restrictions****Benefits;**

**Bug Warnings**Operations on a flattened array `x ({ ,) y`

`x ({. ,) y`

`x (}. ,) y`

`x (e. ,) y`

`f/@, y`

(`f`is any verb)or `@:``&``&:`in place of`@`Avoids copying the array to compute ( `,y`)