// Import in a single file, then across your whole project...
import '@total-typescript/ts-reset'

// .filter just got smarter!
const filteredArray = [1, 2, undefined].filter(Boolean) // number[]

// .includes now takes a string as the first parameter on
// const arrays.
const users = ['matt', 'sofia', 'waqas'] as const
users.includes('bryan')

import { RequireAtLeastOne } from 'type-fest';

type User = {
  id: number;
  password: string;
  firstName: string;
  lastName?: string;
  age: number;
  email: string;
}

type UpdateUser = RequireAtLeastOne<Partial<Omit<User, 'id'>>>;

const updateUser = (userId: User['id'], updateFields: UpdateUser) => { /*...*/ }

// We don't want to allow empty object because that means 
// the operation performed no action:

updateUser(123, {}); // error:  '{}' is not assignable to parameter of type UpdateUser
updateUser(123, { age: 42 }); // ok

import { Pipe, Objects, Strings, ComposeLeft, Tuples, Match } from "hotscript";

type QueryString<V extends string> = Pipe<
  V,
  [
    Strings.Split<"/">,
    Tuples.Filter<Strings.StartsWith<"<">>,
    Tuples.Map<ComposeLeft<[Strings.Trim<"<" | ">">, Strings.Split<":">]>>,
    Tuples.ToUnion,
    Objects.FromEntries,
    Objects.MapValues<
      Match<[Match.With<"string", string>, Match.With<"number", number>]>
    >
  ]
>;

type MyQueryString = QueryString<"/users/<id:string>/posts/<index:number>">;
//      ^? { id: string, index: number }

import { match, P } from 'pattycake';

type Data =
  | { type: 'text'; content: string }
  | { type: 'img'; src: string };

type Result =
  | { type: 'ok'; data: Data }
  | { type: 'error'; error: Error };

const result: Result = ...;

const html = match(result)
  .with({ type: 'error' }, () => <p>Oups! An error occured</p>)
  .with({ type: 'ok', data: { type: 'text' } }, (res) => <p>{res.data.content}</p>)
  .with({ type: 'ok', data: { type: 'img' } }, (res) => <img src={res.data.src} />)
  .exhaustive();

type Shape =
  | { __kind: 'square'; size: number; }
  | { __kind: 'rectangle'; width: number; height: number; }
  | { __kind: 'circle'; radius: number; }

// exhaustive version:
const area1 = exhaustive.tag(s, '__kind', {
  square: (shape) => shape.size ** 2,
  rectangle: (shape) => shape.width * shape.height,
  circle: (shape) => Math.PI * shape.radius ** 2,
});

// ... comparison with ts-pattern or pattycake:
const area2 = match(s)
  .with({ __kind: 'square' }, (shape) => shape.size ** 2)
  .with({ __kind: 'rectangle' }, (shape) => shape.width * shape.height)
  .with({ __kind: 'circle' }, (shape) => Math.PI * shape.radius ** 2)
  .exhaustive();

import { Result } from 'neverthrow';

const safeJsonParse = Result.fromThrowable(JSON.parse);

// This following code never throw error:
safeJsonParse("{").match(
  (data) => console.log(data),
  (e) => console.error('Parse error:', e),
);

// Here is an equivalent using a try/catch block:
try {
  const data = JSON.parse("{");
  console.log(data);
} catch (e: unknown) {
  console.error('Parse error:', e);
}

import "reflect-metadata";

// Building up a simple metadata store...

const Metadata = (metadataValue: any) => Reflect.metadata('metadata-store', metadataValue);

Metadata.get = (target: Object, propertyKey?: string | symbol) =>
Reflect.getMetadata('metadata-store', target, propertyKey as any);

Metadata.set = (metadataValue: any, target: Object, propertyKey?: string | symbol) =>
Reflect.defineMetadata('metadata-store', metadataValue, target, propertyKey as any);

// ... using it:

@Metadata('test1')
class MyClass {
  @Metadata('test2')
  myMethod() {}
}

function myFunction() {}
Metadata.set('test3', myFunction);

let myVar = [1, 4, 6, 1, 7]
Metadata.set('test4', myVar);

console.assert('test1' === Metadata.get(MyClass));
console.assert('test2' === Metadata.get(MyClass.prototype, 'myMethod'));
console.assert('test3' === Metadata.get(myFunction));
console.assert('test4' === Metadata.get(myVar));

// One of the things to be wary about; myVar is now a copy of the
// original object ...
myVar = myVar.filter(x => x > 2);

// ... and so we lost the metadata attached to it:
console.assert(undefined === Metadata.get(myVar));

const arr = [1, 2, 2, 3, 3, 4, 5, 6];

const result = R.pipe(
  arr, // only four iterations instead of eight (array.length)
  R.map(x => {
    console.log('iterate', x);
    return x;
  }),
  R.uniq(),
  R.take(3)
); // => [1, 2, 3]

import { Duration, Effect, Schedule, pipe } from "effect";

// Simple exponential backoff
const retryPolicy = pipe(
  Schedule.exponential(Duration.seconds(1), 0.5),
  Schedule.compose(Schedule.elapsed),
  Schedule.whileOutput(Duration.lessThanOrEqualTo(Duration.seconds(10)))
);

const performTask = (id: number): Effect.Effect<number, string> => {
    // This line will fail the task with id 0 and 5
    if (id % 5 === 0) return Effect.fail(`Database error, id=${id}`)

    // we just return anything here...
    return Effect.succeed(Math.round(id ** 8.1 % id));
}

// Simulate an asynchronous operation with a delay
const simulateAsyncTask = (taskId: number): Effect.Effect<number, string, never> => {
  return pipe(
    Effect.sleep(1000), // Simulate a 1-second delay
    Effect.flatMap(() => performTask(taskId)),
    Effect.tap((r: number) => console.log(`Task ${taskId} completed -- result: ${r}`)),
    Effect.tapError((e: string) => Effect.succeed(console.error(`Task ${taskId} failed with error: ${e}`))),
    Effect.retry(retryPolicy),
    Effect.tapError(() => Effect.succeed(console.error(`Task ${taskId} was killed, maximum retry reached`))),
  );
}

// An array of task IDs (0..10)
const taskIds = Array.from({ length: 10 }, (_, idx) => idx);

// Run the concurrent processing according to the schedule
const runConcurrentlyWithSchedule = pipe(
  taskIds,
  Effect.forEach(simulateAsyncTask, { concurrency: 5 /* batch of 5 */ }),
  Effect.tap((results) => console.log('Result:', results)),
  Effect.asUnit
);

console.info('Starting...');

// Execute the program, it will fail on zero and the try policy will take
// effect, after retrying a few time (as per retry policy) the promise will
// fail and we will enter the catch block.
Effect.runPromise(runConcurrentlyWithSchedule)
  .then(() => console.log('All tasks processed according to the schedule.'))
  .catch(() => console.error('A fatal error occurred, all remaining tasks were stopped'));

Starting...
Task 0 failed with error: Database error, id=0
Task 1 completed -- result: 0
Task 2 completed -- result: 0
Task 3 completed -- result: 3
Task 4 completed -- result: 1
Task 5 failed with error: Database error, id=5
Task 6 completed -- result: 1
Task 7 completed -- result: 4
Task 8 completed -- result: 8
Task 0 failed with error: Database error, id=0
Task 9 completed -- result: 4
Task 5 failed with error: Database error, id=5
Task 0 failed with error: Database error, id=0
Task 5 failed with error: Database error, id=5
Task 0 failed with error: Database error, id=0
...
Task 5 failed with error: Database error, id=5
Task 0 failed with error: Database error, id=0
Task 0 was killed, maximum retry reached
A fatal error occurred, all remaining tasks were stopped