fickl

open Fable.Core
open Fickl.Core

type User = { Name: string; Age: int }

[<Global>]
let fetchUser (id: int) : JS.Promise<User> = jsNative

[<AsyncFunction>]
let adultNames () = jsAsync {
    let! first = fetchUser 1
    and! second = fetchUser 2
    return
        [ first; second ]
        |> List.filter (fun u -> u.Age >= 18)
        |> List.map _.Name
}

import { Record } from "@fable-org/fable-library-js/Types.js";
import { record_type, int32_type, string_type } from "@fable-org/fable-library-js/Reflection.js";
import { ensureResolvedAsyncValue } from "@fable-org/fable-library-js/Util.js";
import { ofArray, filter, map } from "@fable-org/fable-library-js/List.js";

export class User extends Record {
    constructor(Name, Age) {
        super();
        this.Name = Name;
        this.Age = (Age | 0);
    }
}

export function User_$reflection() {
    return record_type("Example1.User", [], User, () => [["Name", string_type], ["Age", int32_type]]);
}

export const adultNames = async function () {
    const _arg = await Promise.all([fetchUser(1), fetchUser(2)]);
    return ensureResolvedAsyncValue(map((_arg_1) => _arg_1.Name, filter((u) => (u.Age >= 18), ofArray([_arg[0], _arg[1]]))));
};

import { Record } from "@fable-org/fable-library-ts/Types.ts";
import type { int32 } from "@fable-org/fable-library-ts/Int32.ts";
import { ensureResolvedAsyncValue, type IComparable, type IEquatable } from "@fable-org/fable-library-ts/Util.ts";
import { record_type, int32_type, string_type, type TypeInfo } from "@fable-org/fable-library-ts/Reflection.ts";
import { type FSharpList, ofArray, filter, map } from "@fable-org/fable-library-ts/List.ts";

export class User extends Record implements IEquatable<User>, IComparable<User> {
    readonly Name: string;
    readonly Age: int32;
    constructor(Name: string, Age: int32) {
        super();
        this.Name = Name;
        this.Age = (Age | 0);
    }
}

export function User_$reflection(): TypeInfo {
    return record_type("Example1.User", [], User, () => [["Name", string_type], ["Age", int32_type]]);
}

export const adultNames = async function (this: any): Promise<FSharpList<string>> {
    const _arg: [User, User] = await Promise.all([fetchUser(1), fetchUser(2)] as [Promise<User>, Promise<User>]);
    return ensureResolvedAsyncValue<FSharpList<string>>(map<User, string>((_arg_1: User): string => _arg_1.Name, filter<User>((u: User): boolean => (u.Age >= 18), ofArray([_arg[0], _arg[1]]))));
};