routine or constant name search
 Up TOC Index << 7 Included Tools < 8.14 Input Routines Up: 8 API Reference 8.16 Sequence Manipulation > 9 Release Notes >>

## 8.15 Searching

### 8.15.1 Equality

#### 8.15.1.1 compare

```<built-in> function compare(object compared, object reference)
```

compares two items returning less than, equal or greater than.

##### Parameters:
1. compared : the compared object
2. reference : the reference object
##### Returns:

An integer,

• 0 -- if objects are identical
• 1 -- if compared is greater than reference
• -1 -- if compared is less than reference

Atoms are considered to be less than sequences. Sequences are compared alphabetically starting with the first element until a difference is found or one of the sequences is exhausted. Atoms are compared as ordinary reals.

##### Example 1:
```x = compare({1,2,{3,{4}},5}, {2-1,1+1,{3,{4}},6-1})
-- identical, x is 0
```
##### Example 2:
```if compare("ABC", "ABCD") < 0 then   -- -1
-- will be true: ABC is "less" because it is shorter
end if
```
##### Example 3:
```x = compare('a', "a")
-- x will be -1 because 'a' is an atom
-- while "a" is a sequence
```

#### 8.15.1.2 equal

```<built-in> function equal(object left, object right)
```

compares two Euphoria objects to see if they are the same.

##### Parameters:
1. left : one of the objects to test
2. right : the other object
##### Returns:

An integer, 1 if the two objects are identical, else 0.

This is equivalent to the expression: compare(left, right) = 0.

This routine, like most other built-in routines, is very fast. It does not have any subroutine call overhead.

##### Example 1:
```if equal(PI, 3.14) then
puts(1, "give me a better value for PI!\n")
end if
```
##### Example 2:
```if equal(name, "George") or equal(name, "GEORGE") then
puts(1, "name is George\n")
end if
```

### 8.15.2 Finding

#### 8.15.2.1 find

```<built-in> function find(object needle, sequence haystack, integer start)
```

finds the first occurrence of a "needle" as an element of a "haystack", starting from position "start".

##### Parameters:
1. needle : an object whose presence is being queried
2. haystack : a sequence, which is being looked up for needle
3. start : an integer, the position at which to start searching. Defaults to 1.
##### Returns:

An integer, 0 if needle is not on haystack, else the smallest index of an element of haystack that equals needle.

##### Example 1:
```location = find(11, {5, 8, 11, 2, 3})
-- location is set to 3
```
##### Example 2:
```names = {"fred", "rob", "george", "mary", ""}
location = find("mary", names)
-- location is set to 4
```

#### 8.15.2.2 find_from

```<built-in> function find_from(object needle, object haystack, integer start)
```
##### Deprecated:

Deprecated since version 4.0.0

In Euphoria 4.0.0 we have the ability to default parameters to procedures and functions. The built-in find therefore now has a start parameter that is defaulted to the beginning of the sequence. Thus, find can perform the identical functionality provided by find_from. In an undetermined future release of Euphoria, find_from will be removed.

#### 8.15.2.3 find_any

```include std/search.e
namespace search
public function find_any(object needles, sequence haystack, integer start = 1)
```

finds any element from a list inside a sequence. Returns the location of the first hit.

##### Parameters:
1. needles : a sequence, the list of items to look for
2. haystack : a sequence, in which "needles" are looked for
3. start : an integer, the starting point of the search. Defaults to 1.
##### Returns:

An integer, the smallest index in haystack of an element of needles, or 0 if no needle is found.

This function may be applied to a string sequence or a complex sequence.

##### Example 1:
```location = find_any("aeiou", "John Smith", 3)
-- location is 8
```
##### Example 2:
```location = find_any("aeiou", "John Doe")
-- location is 2
```

#### 8.15.2.4 match_any

```include std/search.e
namespace search
public function match_any(sequence needles, sequence haystack, integer start = 1)
```

determines if any element from needles is in haystack.

##### Parameters:
1. needles : a sequence, the list of items to look for
2. haystack : a sequence, in which "needles" are looked for
3. start : an integer, the starting point of the search. Defaults to 1.
##### Returns:

An integer, 0 if no matches, 1 if any matches.

This function may be applied to a string sequence or a complex sequence. An empty needles sequence will always result in 0.

##### Example 1:
```ok = match_any("aeiou", "John Smith")
-- okay is 1
ok = match_any("xyz", "John Smith" )
-- okay is 0
```

#### 8.15.2.5 find_each

```include std/search.e
namespace search
public function find_each(sequence needles, sequence haystack, integer start = 1)
```

finds all instances of any element from the needle sequence that occur in the haystack sequence. Returns a list of indexes.

##### Parameters:
1. needles : a sequence, the list of items to look for
2. haystack : a sequence, in which "needles" are looked for
3. start : an integer, the starting point of the search. Defaults to 1.
##### Returns:

A sequence, the list of indexes into haystack that point to an element that is also in needles.

This function may be applied to a string sequence or a complex sequence.

##### Example 1:
```location = find_each("aeiou", "John Smith", 3)
-- location is {8}
```
##### Example 2:
```location = find_each("aeiou", "John Doe")
-- location is {2,7,8}
```

#### 8.15.2.6 find_all

```include std/search.e
namespace search
public function find_all(object needle, sequence haystack, integer start = 1)
```

finds all occurrences of an object inside a sequence, starting at some specified point.

##### Parameters:
1. needle : an object, what to look for
2. haystack : a sequence to search in
3. start : an integer, the starting index position (defaults to 1)
##### Returns:

A sequence, the list of all indexes no less than start of elements of haystack that equal needle. This sequence is empty if no match found.

##### Example 1:
```s = find_all('A', "ABCABAB")
-- s is {1,4,6}
```

#### 8.15.2.7 find_all_but

```include std/search.e
namespace search
public function find_all_but(object needle, sequence haystack, integer start = 1)
```

finds all non-occurrences of an object inside a sequence, starting at some specified point.

##### Parameters:
1. needle : an object, what to look for
2. haystack : a sequence to search in
3. start : an integer, the starting index position (defaults to 1)
##### Returns:

A sequence, the list of all indexes no less than start of elements of haystack that not equal to needle. This sequence is empty if haystack only consists of needle.

##### Example 1:
```s = find_all_but('A', "ABCABAB")
-- s is {2,3,5,7}
```

#### 8.15.2.8 NESTED_ANY

```include std/search.e
namespace search
public constant NESTED_ANY
```

#### 8.15.2.9 NESTED_ALL

```include std/search.e
namespace search
public constant NESTED_ALL
```

#### 8.15.2.10 NESTED_INDEX

```include std/search.e
namespace search
public constant NESTED_INDEX
```

#### 8.15.2.11 NESTED_BACKWARD

```include std/search.e
namespace search
public constant NESTED_BACKWARD
```

#### 8.15.2.12 find_nested

```include std/search.e
namespace search
public function find_nested(object needle, sequence haystack, integer flags = 0,
integer rtn_id = types :NO_ROUTINE_ID)
```

finds any object (among a list) in a sequence of arbitrary shape at arbitrary nesting.

##### Parameters:
1. needle : an object, either what to look up, or a list of items to look up
2. haystack : a sequence, where to look up
3. flags : options to the function, see Comments section. Defaults to 0.
4. routine : an integer, the routine_id of an user supplied equal/find function. Defaults to types:NO_ROUTINE_ID.
##### Returns:

A possibly empty sequence, of results, one for each hit.

Each item in the returned sequence is either a sequence of indexes, or a pair {sequence of indexes, index in needle}.

The following flags are available to fine tune the search:

• NESTED_BACKWARD -- if on flags, search is performed backward. Default is forward.
• NESTED_ALL -- if on flags, all occurrences are looked for. Default is one hit only.
• NESTED_ANY -- if present on flags, needle is a list of items to look for. Not the default.
• NESTED_INDEXES -- if present on flags, an individual result is a pair {position, index in needle}. Default is just return the position.

If s is a single index list, or position, from the returned sequence, then fetch(haystack, s) = needle.

If a routine id is supplied, the routine must behave like equal if the NESTED_ANY flag is not supplied, and like find if it is. The routine is being passed the current haystack item and needle. The returned integer is interpreted as if returned by equal or find.

If the NESTED_ANY flag is specified, and needle is an atom, then the flag is removed.

##### Example 1:
```sequence s = find_nested(3, {5, {4, {3, {2}}}})
-- s is {2 ,2 ,1}
```
##### Example 2:
```sequence s = find_nested({3, 2}, {1, 3, {2,3}},
NESTED_ANY + NESTED_BACKWARD + NESTED_ALL)
-- s is {{3,2}, {3,1}, {2}}
```
##### Example 3:
```sequence s = find_nested({3, 2}, {1, 3, {2,3}},
NESTED_ANY + NESTED_INDEXES + NESTED_ALL)
-- s is {{{2}, 1}, {{3, 1}, 2}, {{3, 2}, 1}}
```

#### 8.15.2.13 rfind

```include std/search.e
namespace search
public function rfind(object needle, sequence haystack, integer start = length(haystack))
```

finds a needle in a haystack in reverse order.

##### Parameters:
1. needle : an object to search for
2. haystack : a sequence to search in
3. start : an integer, the starting index position (defaults to length(haystack))
##### Returns:

An integer, 0 if no instance of needle can be found on haystack before index start, or the highest such index otherwise.

If start is less than 1, it will be added once to length(haystack) to designate a position counted backwards. Thus, if start is -1, the first element to be queried in haystack will be haystack[\$-1], then haystack[\$-2] and so on.

##### Example 1:
```location = rfind(11, {5, 8, 11, 2, 11, 3})
-- location is set to 5
```
##### Example 2:
```names = {"fred", "rob", "rob", "george", "mary"}
location = rfind("rob", names)
-- location is set to 3
location = rfind("rob", names, -4)
-- location is set to 2
```

#### 8.15.2.14 find_replace

```include std/search.e
namespace search
public function find_replace(object needle, sequence haystack, object replacement,
integer max = 0)
```

finds a needle in the haystack, and replaces all or upto max occurrences with replacement.

##### Parameters:
1. needle : an object to search and perhaps replace
2. haystack : a sequence to be inspected
3. replacement : an object to substitute for any (first) instance of needle
4. max : an integer, 0 to replace all occurrences
##### Returns:

A sequence, the modified haystack.

Replacements will not be made recursively on the part of haystack that was already changed.

If max is 0 or less, any occurrence of needle in haystack will be replaced by replacement. Otherwise, only the first max occurrences are.

##### Example 1:
```s = find_replace('b', "The batty book was all but in Canada.", 'c', 0)
-- s is "The catty cook was all cut in Canada."
```
##### Example 2:
```s = find_replace('/', "/euphoria/demo/unix", '\\', 2)
-- s is "\\euphoria\\demo/unix"
```
##### Example 3:
```s = find_replace("theater", { "the", "theater", "theif" }, "theatre")
-- s is { "the", "theatre", "theif" }
```

#### 8.15.2.15 match_replace

```include std/search.e
namespace search
public function match_replace(object needle, sequence haystack, object replacement,
integer max = 0)
```

finds a "needle" in a "haystack", and replace any, or only the first few, occurrences with a replacement.

##### Parameters:
1. needle : an non-empty sequence or atom to search and perhaps replace
2. haystack : a sequence to be inspected
3. replacement : an object to substitute for any (first) instance of needle
4. max : an integer, 0 to replace all occurrences
##### Returns:

A sequence, the modified haystack.

Replacements will not be made recursively on the part of haystack that was already changed.

If max is 0 or less, any occurrence of needle in haystack will be replaced by replacement. Otherwise, only the first max occurrences are.

If either needle or replacement are atoms they will be treated as if you had passed in a length-1 sequence containing the said atom.

If needle is an empty sequence, an error will be raised and your program will exit.

##### Example 1:
```s = match_replace("the", "the cat ate the food under the table", "THE", 0)
-- s is "THE cat ate THE food under THE table"
```
##### Example 2:
```s = match_replace("the", "the cat ate the food under the table", "THE", 2)
-- s is "THE cat ate THE food under the table"
```
##### Example 3:
```s = match_replace('/', "/euphoria/demo/unix", '\\', 2)
-- s is "\\euphoria\\demo/unix"
```
##### Example 4:
```s = match_replace('a', "abracadabra", 'X')
-- s is now "XbrXcXdXbrX"
-- s is now "brcdbr"
```

#### 8.15.2.16 binary_search

```include std/search.e
namespace search
public function binary_search(object needle, sequence haystack, integer start_point = 1,
integer end_point = 0)
```

finds a "needle" in an ordered "haystack". Start and end point can be given for the search.

##### Parameters:
1. needle : an object to look for
2. haystack : a sequence to search in
3. start_point : an integer, the index at which to start searching. Defaults to 1.
4. end_point : an integer, the end point of the search. Defaults to 0, ie search to end.
##### Returns:

An integer, either:

1. a positive integer i, which means haystack[i] equals needle.
2. a negative integer, -i, with i between adjusted start and end points. This means that needle is not in the searched slice of haystack, but would be at index i if it were there.
3. a negative integer -i with i out of the searched range. This means than needlemight be either below the start point if i is below the start point, or above the end point if i is.
• If end_point is not greater than zero, it is added to length(haystack) once only. Then, the end point of the search is adjusted to length(haystack) if out of bounds.
• The start point is adjusted to 1 if below 1.
• The way this function returns is very similar to what db_find_key does. They use variants of the same algorithm. The latter is all the more efficient as haystack is long.
• haystack is assumed to be in ascending order. Results are undefined if it is not.
• If duplicate copies of needle exist in the range searched on haystack, any of the possible contiguous indexes may be returned.

### 8.15.3 Matching

#### 8.15.3.1 match

```<built-in> function match(sequence needle, sequence haystack, integer start)
```

tries to match a "needle" against some slice of a "haystack", starting at position "start".

##### Parameters:
1. needle : a sequence whose presence as a "substring" is being queried
2. haystack : a sequence, which is being looked up for needle as a sub-sequence
3. start : an integer, the point from which matching is attempted. Defaults to 1.
##### Returns:

An integer, 0 if no slice of haystack is needle, else the smallest index at which such a slice starts.

If needle is an empty sequence, an error is raised and your program will exit.

##### Example 1:
```location = match("pho", "Euphoria")
-- location is set to 3
```

#### 8.15.3.2 match_from

```<built-in> function match_from(sequence needle, sequence haystack, integer start)
```
##### Deprecated:

Deprecated since version 4.0.0

In Euphoria 4.0.0 we have the ability to default parameters to procedures and functions. The built-in match therefore now has a start parameter that is defaulted to the beginning of the sequence. Thus, match can perform the identical functionality provided by match_from. In an undetermined future release of Euphoria, match_from will be removed.

If needle is an empty sequence, an error is raised and your program will exit.

#### 8.15.3.3 match_all

```include std/search.e
namespace search
public function match_all(sequence needle, sequence haystack, integer start = 1)
```

matches all items of haystack in needle.

##### Parameters:
1. needle : a non-empty sequence, what to look for
2. haystack : a sequence to search in
3. start : an integer, the starting index position (defaults to 1)
##### Returns:

A sequence, of integers, the list of all lower indexes, not less than start, of all slices in haystack that equal needle. The list may be empty.

If needle is an empty sequence, an error will be raised and your program will exit.

##### Example 1:
```s = match_all("the", "the dog chased the cat under the table.")
-- s is {1,16,30}
```

#### 8.15.3.4 rmatch

```include std/search.e
namespace search
public function rmatch(sequence needle, sequence haystack, integer start = length(haystack))
```

tries to match a needle against some slice of a haystack in reverse order.

##### Parameters:
1. needle : a sequence to search for
2. haystack : a sequence to search in
3. start : an integer, the starting index position (defaults to length(haystack))
##### Returns:

An integer, either 0 if no slice of haystack starting before start equals needle, else the highest lower index of such a slice.

If start is less than 1, it will be added once to length(haystack) to designate a position counted backwards. Thus, if start is -1, the first element to be queried in haystack will be haystack[\$-1], then haystack[\$-2] and so on.

If a needle is an empty sequence this will return 0.

##### Example 1:
```location = rmatch("the", "the dog ate the steak from the table.")
-- location is set to 28 (3rd 'the')
location = rmatch("the", "the dog ate the steak from the table.", -11)
-- location is set to 13 (2nd 'the')
```

#### 8.15.3.5 begins

```include std/search.e
namespace search
public function begins(object sub_text, sequence full_text)
```

tests whether a sequence is the head of another one.

##### Parameters:
1. sub_text : an object to be looked for
2. full_text : a sequence, the head of which is being inspected.
##### Returns:

An integer, 1 if sub_text begins full_text, else 0.

If sub_text is an empty sequence, this returns 1 unless full_text is also an empty sequence. When they are both empty sequences this returns 0.

##### Example 1:
```s = begins("abc", "abcdef")
-- s is 1
s = begins("bcd", "abcdef")
-- s is 0
```

#### 8.15.3.6 ends

```include std/search.e
namespace search
public function ends(object sub_text, sequence full_text)
```

tests whether a sequence ends another one.

##### Parameters:
1. sub_text : an object to be looked for
2. full_text : a sequence, the tail of which is being inspected.
##### Returns:

An integer, 1 if sub_text ends full_text, else 0.

If sub_text is an empty sequence, this returns 1 unless full_text is also an empty sequence. When they are both empty sequences this returns 0.

##### Example 1:
```s = ends("def", "abcdef")
-- s is 1
s = begins("bcd", "abcdef")
-- s is 0
```

#### 8.15.3.7 is_in_range

```include std/search.e
namespace search
public function is_in_range(object item, sequence range_limits, sequence boundries = "[]")
```

tests to see if the item is in a range of values supplied by range_limits.

##### Parameters:
1. item : The object to test for.
2. range_limits : A sequence of two or more elements. The first is assumed to be the smallest value and the last is assumed to be the highest value.
3. boundries: a sequence. This determines if the range limits are inclusive or not. Must be one of "[]" (the default), "[)", "(]", or "()".
##### Returns:

An integer, 0 if item is not in the range_limits otherwise it returns 1.

• In boundries, square brackets mean inclusive and round brackets mean exclusive. Thus "[]" includes both limits in the range, while "()" excludes both limits. And, "[)" includes the lower limit and excludes the upper limits while "(]" does the reverse.
##### Example 1:
```if is_in_range(2, {2, 75}) then
procA(user_data) -- Gets run (both limits included)
end if
if is_in_range(2, {2, 75}, "(]") then
procA(user_data) -- Does not get run
end if
```

#### 8.15.3.8 is_in_list

```include std/search.e
namespace search
public function is_in_list(object item, sequence list)
```

tests to see if the item is in a list of values supplied by list.

##### Parameters:
1. item : The object to test for.
2. list : A sequence of elements that item could be a member of.
##### Returns:

An integer, 0 if item is not in the list, otherwise it returns 1.

##### Example 1:
```if is_in_list(user_data, {100, 45, 2, 75, 121}) then
procA(user_data)
end if
```

#### 8.15.3.9 lookup

```include std/search.e
namespace search
public function lookup(object find_item, sequence source_list, sequence target_list,
object def_value = 0)
```

returns the corresponding element from the target list if the supplied item is in the source list.

##### Parameters:
1. find_item: an object that might exist in source_list.
2. source_list: a sequence that might contain pITem.
3. target_list: a sequence from which the corresponding item will be returned.
4. def_value: an object (defaults to zero). This is returned when find_item is not in source_list and target_list is not longer than source_list.
##### Returns:

An object

• If find_item is found in source_list then this is the corresponding element from target_list
• If find_item is not in source_list then if target_list is longer than source_list then the last item in target_list is returned otherwise def_value is returned.
##### Example 1:
```lookup('a', "cat", "dog") --> 'o'
lookup('d', "cat", "dogx") --> 'x'
lookup('d', "cat", "dog") --> 0
lookup('d', "cat", "dog", -1) --> -1
lookup("ant", {"ant","bear","cat"}, {"spider","seal","dog","unknown"})
--> "spider"
lookup("dog", {"ant","bear","cat"}, {"spider","seal","dog","unknown"})
--> "unknown"
```

#### 8.15.3.10 vlookup

```include std/search.e
namespace search
public function vlookup(object find_item, sequence grid_data, integer source_col,
integer target_col, object def_value = 0)
```

returns the corresponding element from the target column if the supplied item is in a source grid column.

##### Parameters:
1. find_item: an object that might exist in source_col.
2. grid_data: a 2D grid sequence that might contain pITem.
3. source_col: an integer. The column number to look for find_item.
4. target_col: an integer. The column number from which the corresponding item will be returned.
5. def_value: an object (defaults to zero). This is returned when find_item is not found in the source_col column, or if found but the target column does not exist.
• If a row in the grid is actually a single atom, the row is ignored.
• If a row's length is less than the source_col, the row is ignored.
##### Returns:

An object,

• If find_item is found in the source_col column then this is the corresponding element from the target_col column.
##### Example 1:
```sequence grid
grid = {
{"ant", "spider", "mortein"},
{"bear", "seal", "gun"},
{"cat", "dog", "ranger"},
\$
}
vlookup("ant", grid, 1, 2, "?") --> "spider"
vlookup("ant", grid, 1, 3, "?") --> "mortein"
vlookup("seal", grid, 2, 3, "?") --> "gun"
vlookup("seal", grid, 2, 1, "?") --> "bear"
vlookup("mouse", grid, 2, 3, "?") --> "?"
```

 Up TOC Index << 7 Included Tools < 8.14 Input Routines Up: 8 API Reference 8.16 Sequence Manipulation > 9 Release Notes >>