jfet97

const ticker = interval(1000).pipe(take(100));

function snooze(ms) {
  return new Promise(resolve => setTimeout(snooze, ms));
}

async function* values() {
  for await (const number of ticker) {
    await snooze(2000);
    yield number;

jfet97

class ConstNumber {
    #privateNumber: number;
    #dfbsdfbv =4235;
    showCallback: (value: number) => void;

    constructor(privateNumber: number, showCallback: (value: number) => void) {
        this.#privateNumber = privateNumber;
        this.showCallback = showCallback;
    }

jfet97

type ActionsTypesExample = "INIT" | "SYNC" | "LOG_IN" | "LOG_IN_SUCCESS" | "LOG_OUT"

type SafeKeyValueMapExample<KS extends keyof any> = {
    readonly [K in KS]: K;
};

const ACTIONS_TYPES_MAP_EXAMPLE: SafeKeyValueMapExample<ActionsTypesExample> = {
    INIT: "INIT",
    SYNC: "SYNC",
    LOG_IN: "LOG_IN",

jfet97

// https://gal.hagever.com/posts/typing-the-technical-interview-in-typescript/

type Eq<A, B extends A> = "passes"; // B <= A

// type test_eq = [
//   Eq<"Hello", "Hello">, // passes
//   Eq<"Hello", "world"> // fails with "'world' does not satisfy constraint 'Hello'"
// ];

type NAN = "invalid number"; // we don't support negative numbers

jfet97

const Point = (x = 0, y = 0) => ({
    setCartesianCoordinates(_x, _y) {
        x = _x; y = _y;
    },
    setPolarCoordinates(radius, angle) {
        x = radius * Math.cos(angle);
        y = radius * Math.sin(angle);
    },
    getCartesianCoordinates() {
        return { x, y }

jfet97

data Expr = Val Int | Add Expr Expr | Mul Expr Expr deriving (Show)

data Op = EVALA Expr | ADD Int | EVALM Expr | MUL Int
type Cont = [Op]

eval :: Expr -> Cont -> Int
eval (Val n) c = exec c n
eval (Add e f) c = eval e (EVALA f : c)
eval (Mul e f) c = eval e (EVALM f : c)

jfet97

export interface Message {
    status: string;
    query: string;
    step: string;
    richResponse: boolean;
    payload: Types extends (any) ? Payload<Types> : never;
    sessionId?: number;
}

type Types = 'text' | 'date' | 'articles' | 'params';

jfet97

function bind(ambient, name, value) {
  return function lookup(n) {
    if(n == name) {
      return value
    } else {
      return ambient(n)
    }
  }
}

jfet97

import Control.Applicative
import Data.Char


newtype Parser a = P (String -> [(a, String)])

parse :: Parser a -> String -> [(a, String)]
parse (P p) s = p s

instance Functor Parser where

jfet97

const scope = callback => ({
  with: Function(`with(arguments[0])return(${callback})()`)
});

scope(() => ['a', test, 'c']).with({test: 'b'});

// ["a", "b", "c"]