Return multiple values from function

I'd like to add that one of the main use-cases for multiple return values in Go is error handling which Dart handle's in its own way with Exceptions and failed promises.

Of course this leaves a few other use-cases, so let's see how code looks when using explicit tuples:

import 'package:tuple/tuple.dart';

Tuple2<int, String> demo() {
  return new Tuple2(42, "life is good");
}

void main() {
  final result = demo();
  if (result.item1 > 20) {
    print(result.item2);
  }
}

Not quite as concise, but it's clean and expressive code. What I like most about it is that it doesn't need to change much once your quick experimental project really takes off and you start adding features and need to add more structure to keep on top of things.

class FormatResult {
  bool changed;
  String result;
  FormatResult(this.changed, this.result);
}

FormatResult powerFormatter(String text) {
  bool changed = false;
  String result = text;
  // secret implementation magic
  // ...
  return new FormatResult(changed, result);
}

void main() {
  String draftCode = "print('Hello World.');";
  final reformatted = powerFormatter(draftCode);
  if (reformatted.changed) {
    // some expensive operation involving servers in the cloud.
  }
}

So, yes, it's not much of an improvement over Java, but it works, it is clear, and reasonably efficient for building UIs. And I really like how I can quickly hack things together (sometimes starting on DartPad in a break at work) and then add structure later when I know that the project will live on and grow.

Create a class:

import 'dart:core';

class Tuple<T1, T2> {
  final T1 item1;
  final T2 item2;

  Tuple({
    required this.item1,
    required this.item2,
  });

  factory Tuple.fromJson(Map<String, dynamic> json) {
    return Tuple(
      item1: json['item1'],
      item2: json['item2'],
    );
  }
}

Call it however you want!

Tuple<double, double>(item1: i1,item2: i2);
or
Tuple<double, double>.fromJson(jsonData);

You can create a class to return multiple values Ej:

class NewClass {
  final int number;
  final String text;

  NewClass(this.number, this.text);
}

Function that generates the values:

 NewClass buildValues() {
        return NewClass(42, 'foobar');
      }

Print:

void printValues() {
    print('${this.buildValues().number} ${this.buildValues().text}');
    // 42 foobar
  }

Dart is finalizing records, a fancier tuple essentially.
Should be in a stable release with Dart 3.
It's already available with experiments flags.

As other answers have noted, Dart 3.0 adds records, which can be used to return multiple values in a type-safe way.

For earlier versions of Dart, the proper way to return multiple values would be to store those values in a class, whether your own custom class or a Tuple. However, defining a separate class for every function is very inconvenient, and using Tuples can be error-prone since the members won't have meaningful names.

Another (admittedly gross and not very Dart-istic) approach is try to mimic the output-parameter approach typically used by C and C++. For example:

class OutputParameter<T> {
  T value;

  OutputParameter(this.value);
}

void foo(
  OutputParameter<int> intOut,
  OutputParameter<String>? optionalStringOut,
) {
  intOut.value = 42;
  optionalStringOut?.value = 'foobar';
}

void main() {
  var theInt = OutputParameter(0);
  var theString = OutputParameter('');
  foo(theInt, theString);
  print(theInt.value); // Prints: 42
  print(theString.value); // Prints: foobar
}

It certainly can be a bit inconvenient for callers to have to use variable.value everywhere, but in some cases it might be worth the trade-off.

This is now available in Dart 3.0 (Flutter 3.10.0). They are called "Records" (full doc here).

Here are some of my favorite examples:

Return types

(int x, double y) geoLocation(String name) =>
    return (-1, 36.8219);

Accessing them:

var record = ('first', a: 2, b: true, 'last');

print(record.$1); // Prints 'first'
print(record.a); // Prints 2
print(record.b); // Prints true
print(record.$2); // Prints 'last'

Variables

// Record type annotation in a variable declaration:
(String, int) record;

// Initialize it with a record expression:
record = ('A string', 123);

Named args!

// Record type annotation in a variable declaration:
({int a, bool b}) record;

// Initialize it with a record expression:
record = (a: 123, b: true);

you can use Set<Object> for returning multiple values,

Set<object> foo() {
     return {'my string',0}
}

print(foo().first) //prints 'my string'

print(foo().last) //prints 0

you can use dartz package for Returning multiple data types

https://www.youtube.com/watch?v=8yMXUC4W1cc&t=110s

Dart allows to return multiple values.

dart --version
Dart SDK version: 3.9.0 (stable) (Mon Aug 11 07:58:10 2025 -0700) on "macos_arm64"

(String, String) _getErrorMessageAndCode(ErrorType errorType) {
switch(errorType) {
case ConnectionError: return ('Failed to connect: Connection Timeout Error', 'ERR10001'
case GenericError: return ('Internal Server Error: Failed to process', 'ERR10002'
case NetworkTimeout: return ('Network timeout: Possible offline', 'ERR10004'
}

Caller can call this as normal function

final errorMessageAndId = _getErrorMessageAndCode(ErrorType.ConnectionError);

As the function _getErrorMessageAndCode returns multi values, the syntax to retrieve the values are using $ notation

final errorMessage = errorMessageAndId.$1 and final errorCode = errorMessageAndId.$2

In this type of situation in Dart, an easy solution could return a list then accessing the returned list as per your requirement. You can access the specific value by the index or the whole list by a simple for loop.

List func() {
  return [false, 30, "Ashraful"];
}

void main() {
  final list = func();
  
  // to access specific list item
  var item = list[2];
  
  // to check runtime type
  print(item.runtimeType);
  
  // to access the whole list
  for(int i=0; i<list.length; i++) {
    print(list[i]);
  }
}