Nesting (computing)

From Wikipedia, the free encyclopedia
Jump to: navigation, search

In computing science and informatics, the word nesting may denote several different constructions and activities where information is organized in layers or objects contain other similar objects. The rather general term is thus used in quite specific ways for various situations and concepts depending on context, which is sometimes only remotely related. However, it almost always refers to self-similar or recursive structures in some sense.

The word has been used to denote:

In spreadsheets[edit]

In a spreadsheet functions can be nested one into another, making complex formulas. The function wizard of the OpenOffice.org Calc application allows to navigate through multiple levels of nesting,[further explanation needed] letting the user to edit (and possibly correct) each one of them separately.

Naturally, to allow the mathematical resolution of these chained (or better: nested) formulas, the inner expressions must be previously evaluated, and this outward direction is essential because the results that the internal functions return are temporarily used as entry data for the external ones.

Due to the potential accumulation of parentheses in only one code line, editing and error detecting (or debugging) can became somehow awkward. That is why modern programming environments -as well as spreadsheet programs- highlight in bold type the pair corresponding to the current editing position. The (automatic) balancing control of the opening and closing parenthesis known as brace match checking.

In programming[edit]

In structured programming languages, nesting is related to the enclosing of control structures one into another, usually indicated through different indentation levels within the source code, as it is shown in this simple BASIC function:

function LookupCode(code as string) as integer
  dim sLine, path as string
  dim return_value as integer
 
  path="C:\Test.csv"
  if FileExists(path) then
    open path for input as #1
    do while not EOF(1)
      line input #1, sLine
      if left(sLine, 3)=code then
        'Action(s) to be carried out
      End if
    loop
    close #1
  End if
  LookupCode=return_value
end function

In this small and simple example, the conditional block “if... then... end if” is nested inside the “do while... loop” one.

Some languages such as Pascal and Ada have no restrictions on declarations depending on the nesting level, allowing precisely nested subprograms or even nested packages (Ada). Here is an example of both (simplified from a real case):

-- Getting rid of the global variables issue (cannot be used in parallel)
-- from a set of old sources, without the need to change that code's
-- logic or structure.
--
procedure Nesting_example_1 is
 
  type Buffer_type is array(Integer range <>) of Integer;
 
  procedure Decompress(
    compressed  :  in Buffer_type;
    decompressed: out Buffer_type
  )
  is
    -- Here are the legacy sources, translated:
    package X_Globals is
      index_in, index_out: Integer;
      -- *** ^ These variables are local to Decompress.
      -- ***   Now Decompress is task-safe.
    end X_Globals;
    -- Methods 1,2,3,... (specifications)
    package X_Method_1 is
      procedure Decompress_1;
    end X_Method_1;
    -- Methods 1,2,3,... (code)
    package body X_Method_1 is
      use X_Globals;
      procedure Decompress_1 is
      begin
        index_in:= compressed'First;
        -- Here, the decompression code, method 1
      end Decompress_1;
    end X_Method_1;
    -- End of the legacy sources
  begin
    X_Method_1.Decompress_1;
  end Decompress;
 
  test_in, test_out: Buffer_type(1..10_000);
 
begin
  Decompress(test_in, test_out);
end Nesting_example_1;

References[edit]

See also[edit]