بازگشت مد کلاسیک در TS: خود مرجع از نوع تابع

export type RecFunc = (n: number, f: RecFunc) => number;

export function fix_point(f: RecFunc): (x: number) => number {
        return x => f(x, f)
}

import { RecFunc, fix_point } from './genericMemoization.js'

const fibPrimitive = (n: number, selfFib: RecFunc): number => n <= 0? 0: n == 1? 1: selfFib(n-1, selfFib) + selfFib(n-2, selfFib);

const fib = fix_point(fibPrimitive);
console.log(fib(12)); // 144

export type RecFunc2 = (m:number, n: number, f: RecFunc) => number;

export function fix_point2(f: RecFunc2): (x: number, y: number) => number {
        return (x, y) => f(x, y, f)
}

import { RecFunc2, fix_point2 } from './genericMemoization.js'

const ackPrimitive = (m:number, n: number, selfAck: RecFunc2): number => {
  if (m == 0) return n + 1;
  if (n == 0) return selfAck(m-1, 1, selfAck);
  return selfAck(m-1, selfAck(m, n-1, selfAck), selfAck);
}

const ack = fix_point2(ackPrimitive);

type ParamLogger = {
    log: (param: number) => void,
    deeper_logger: () => ParamLogger
}

const lyingLogger: ParamLogger = {
    log: (param: number) => console.log(`0: ${param}`),
    deeper_logger: () => lyingLogger
}

const loggerByLevel = (level: number): ParamLogger => ({
    log: (param: number) => console.log(`${level}: ${param}`),
    deeper_logger: () => loggerByLevel(level + 1)
})

const baseLogger: ParamLogger = (() => {
    const loggerByLevel = (level: number): ParamLogger => ({
        log: (param: number) => console.log(`${level}: ${param}`),
        deeper_logger: () => loggerByLevel(level + 1)
    })
    return loggerByLevel(0)
})();

const baseLogger: ParamLogger = (() => {
    type ParamLoggerCreator = (level: number, func: ParamLoggerCreator) => ParamLogger

    const loggerByLevel: ParamLoggerCreator = (level: number, func: ParamLoggerCreator) => ({
        log: (param: number) => console.log(`${level}: ${param}`),
        deeper_logger: () => func(level + 1, func)
    })
    return loggerByLevel(0, loggerByLevel)
})();

fibPrimitive(12, (n, self) => {
    console.log(n)
    return fibPrimitive(n, self)
})

function fix_point_log(f: RecFunc): (n: number) => number {
    const logging = (n: number, self: RecFunc): number => {
        baseLogger.log(n)
        return f(n, logging)
    }
    return n => logging(n, logging)
}

function fix_point_log(f: RecFunc): (n: number) => number {
    const logging = (n: number, self: RecFunc): number => {
        baseLogger.log(n)
        const step = (n: number, s: RecFunc): number => {
            return self(n, s)
        }
        return f(n, step)
    }
    return n => logging(n, logging)
}

function fix_point_log(f: RecFunc): (n: number) => number {
    const logging = (n: number, self: RecFunc): number => {
        baseLogger.log(n)
        const step = (n: number, s: RecFunc): number => {
            return self(n, s)
        }
        step.log = baseLogger.deeper_logger()
        return f(n, step)
    }
    return n => logging(n, logging)
}

type TipoDeStep = RecFunc & { log: ParamLogger }

// ou então equivalentemente...

type TipoDeStep = ((n: number, s: RecFunc) => number) & { log: ParamLogger }

// outra maneira...

type TipoDeStep = {
    (n: number, s: RecFunc): number,
    log: ParamLogger
}

type BinOp = {
    (a: number, b: number): number,
    nome: string
}

const soma: BinOp = (a, b) => a + b
soma.nome = "+"

type BinOp = {
    (a: number, b: number): number,
    nome: string
}

const soma: BinOp = (a, b) => a + b
// erro de TS
// Property 'nome' is missing in type '(a: number, b: number) => number' but required in type 'BinOp'.ts(2741)

function isRecFuncEtlog(f: RecFunc): f is RecFunc & { log: ParamLogger } {
    return (f as any)["log"] != null
}

function fix_point_log(f: RecFunc): (n: number) => number {
    const logging = (n: number, self: RecFunc): number => {
        if (isRecFuncEtlog(self)) {
            self.log.log(n)
            return f(n, self)
        }
        baseLogger.log(n)
        const step = (n: number, s: RecFunc): number => {
            return self(n, s)
        }
        step.log = baseLogger.deeper_logger()
        return f(n, step)
    }
    return n => logging(n, logging)
}

function fix_point_log(f: RecFunc): (n: number) => number {
    const logging = (n: number, self: RecFunc): number => {
        if (isRecFuncEtlog(self)) {
            self.log.log(n)
            const step = (n: number, s: RecFunc): number => {
                return self(n, s)
            }
            step.log = self.log.deeper_logger()
            return f(n, step)
        }
        baseLogger.log(n)
        const step = (n: number, s: RecFunc): number => {
            return self(n, s)
        }
        step.log = baseLogger.deeper_logger()
        return f(n, step)
    }
    return n => logging(n, logging)
}