In Dart, you can write functions within functions because it is a true object-oriented language. Functions are objects that have type Function. 

The inner (nested) function is private to its outer function. Only the outer function can access the inner function by calling it. In Dart, functions form closures, which allow them to be nested. The inner function forms a *closure* around its variables; therefore, the outer function cannot use the arguments and variables of the inner function. However, since the inner function is within the closure of the outer function, it can access variables and operations from the outer function that have been declared before it. 
> A closure defines the scope of objects.




In the example below, we nest `square` in the `circleArea` function.



import 'dart:html';
import 'dart:math' show pi;



double circleArea(double radius){   // outer function
  double square(double r) {       // inner/nested function
    return r * r;
  }
  return 3.14 * square(radius);
  // return pi * square(radius); 
  
  // if you're particular about accuracy you 
  // can use the second return statement 
}

// Alternative syntax using '=>'
// double circleArea(double radius){
//   double square(double r) => r * r;  
//   return 3.14 * square(radius);
// }


void main() {
  double radius = 5;
  double area = circleArea(radius);
  querySelector('#container').text =
  'The radius of circle with $radius is $area.';
}

import React from 'react';
import { shallow, configure } from 'enzyme';
import Adapter from 'enzyme-adapter-react-16';

configure({ adapter: new Adapter() });

import HelloWorld from './app';

var TestResult = function() {
    this.succeeded = false;
    this.reason = "";
    this.input = "";
    this.expected_output = "";
    this.actual_output = "";
}

export const executeTests = function() {

  var results = [];

  result = new TestResult();
  result.input = 'HelloWorld Component';
  result.expected_output = "span containing text 'Hello World'"

  let wrapper = shallow(<HelloWorld />);

  // Call your Challenge function here.

  let type = wrapper.type();
  let testSuccessful = true;
  let failureReason;

  if (type !== 'span') {
    testSuccessful = false;
    failureReason = "You need to render exactly one span HTML element";
  } else if (wrapper.props().children != "Hello World") {
     testSuccessful = false;
     failureReason = "You have rendered wrong message in your span element";
  }

  result.actual_output = wrapper.html();

  if (testSuccessful) {
    result.succeeded = true;
    result.reason = "Succeeded"
  } else {
    result.succeeded = false;
    result.reason = failureReason;
  }

  results.push(result);

  return results;
}


React

Dart

GoJS React

Typescript React

Vue.js

# Nest functions in multiple layers

You can have multiple layers of nest functions. In the example below, you can observe two layers of nested functionality. This is also a good example of scope within closures (where `c` has access to elements of `b` and `a`, but the opposite is not true).  


import 'dart:html';
import "dart:math" show pi;

String nestedFun(){
  a(String x){
    b(String y){
      c(String z){
        return x + ' ' + y + ' ' + z;
      }
      return c('coffee'); // z
    }
    return b('need');     // y
  }
  return a('I');          // x
} 


void main() {
  querySelector('#container').text =
  nestedFun();
}

How to create a nested function in Dart

In Dart, you can nest functions within functions, allowing closures to access outer function variables while maintaining scope limitations.

How to create a nested function in Dart

Implementation

Nest functions in multiple layers