Cold, composable
computations for Dart

import 'package:jerelo/jerelo.dart';

// Run fetch and name-validation in parallel.
// Both must succeed; fail fast on the first error.
Cont<void, String, UserProfile> fetchAndUpdate(
  String accessToken, {
  required String newName,
}) {
  return Cont.both(
    getUserProfile(accessToken),
    validateName(newName),
    (profile, validName) => profile.copyWith(name: validName),
    policy: OkPolicy.quitFast(),
  ).thenDo((merged) {
    return updateUserProfile(accessToken, merged);
  });
}

// Fetch multiple users concurrently; preserve order.
Cont<AppConfig, String, List<User>> getUsers(List<String> ids) {
  return Cont.all(
    ids.map(getUserData).toList(),
    policy: OkPolicy.quitFast(),
  );
}

// Race two strategies — normal login vs. stored refresh token.
// Return whichever succeeds first.
final loginFlow = Cont.either(
  loginRequest('user@test.com', 'password'),
  refreshTokenLogin(storedToken),
  (e1, e2) => '$e1; $e2',
  policy: OkPolicy.sequence(),
);

import 'package:jerelo/jerelo.dart';

// Build the full login-to-session flow.
final loginToSession = loginRequest('user@test.com', 'secret')
  .thenDo((token) {
    return getUserProfile(token.accessToken)
      .thenMap((profile) => Session(token: token, profile: profile));
  })
  // Log the session without changing its value.
  .thenTap((session) {
    print('[LOG] Authenticated as ${session.profile.name}');
    return Cont.of(());
  });

// Execute — all three outcome channels handled explicitly.
final token = loginToSession.run(
  null,
  // Success channel: computation produced a value.
  onThen: (session) {
    print('Welcome, ${session.profile.name}!');
  },
  // Else channel: expected business error (typed as String here).
  onElse: (error) {
    print('Login failed: $error');
  },
  // Crash channel: unexpected exception — never swallowed silently.
  onCrash: (crash) {
    print('Unexpected crash: $crash');
  },
);

// Cancel at any time. The running leaf decides how to stop and
// reports through one of the channels above.
// token.cancel();

import 'dart:async';
import 'dart:io';
import 'package:jerelo/jerelo.dart';

// A leaf returns a canceller: it decides what cancelling means.
Cont<(), String, String> download(String url) {
  return Cont.fromRun((env, observer) {
    final timer = Timer(Duration(seconds: 2), () {
      observer.onThen('contents of $url');
    });
    // Stop the work and report through a channel.
    return () {
      timer.cancel();
      observer.onElse('cancelled');
    };
  });
}

final token = download('https://example.com')
  .thenMap((body) => body.length)
  .run(
    (),
    onElse: (e) => print('else: $e'), // else: cancelled
    onThen: (n) => print('got $n'),
  );

token.cancel(); // forwarded to the running leaf

// bracket: release runs once `use` reports back, on any channel.
Cont<(), String, String> readFile(String path) {
  return Cont.bracket<RandomAccessFile, (), String, String>(
    acquire: openFile(path),
    release: (file) => closeFile(file),
    use: (file) => Cont.of('${file.lengthSync()} bytes'),
  );
}

import 'package:jerelo/jerelo.dart';

// One million sequential steps, built in a loop.
var chain = Cont.of<(), String, int>(0);
for (var i = 0; i < 1000000; i++) {
  chain = chain.thenDo((n) => Cont.of(n + 1));
}

// Runs in constant stack space: no overflow, no lost outcome.
chain.run((), onThen: print); // 1000000

// The same holds for thenMap, elseDo, crashDo,
// Cont.fromDeferred and local, and for recursion:
Cont<(), String, int> count(int i) {
  return i == 1000000
    ? Cont.of(i)
    : Cont.fromDeferred(() => count(i + 1));
}

// A Cont is data, so it can run any number of times,
// also concurrently — each run has its own state.
count(0).run((), onThen: print);
count(0).run((), onThen: print);