FunctionalScript

Apr 09 2023

Uma história típica de negócios em crescimento Por experiência própria, vi muitas vezes que negócios em crescimento passam pelos seguintes estágios semelhantes: O problema com o uso direto de IO em bibliotecas Quando as bibliotecas usam operações de IO diretamente, isso limita a reutilização da lógica da biblioteca. O uso de IO direto age como um vírus, tornando uma biblioteca inutilizável quando o sistema de IO é alterado.

Uma história típica de negócios em crescimento

Por experiência própria, vi muitas vezes que empresas em crescimento passam pelos seguintes estágios semelhantes:

Usando o Excel para contabilidade, inventário e outras tarefas de gerenciamento.
Implementar a mesma lógica de negócios em um programa personalizado com uma interface de usuário e serializar dados para JSON ou XML.
Reescrever o programa para suportar multithreading ou processamento assíncrono.
Reescrevendo o programa para usar o banco de dados SQL.
Reescrever o programa para Java para usar sistemas distribuídos como o Hadoop .
Reescrever o programa para Scala para compatibilidade com Spark .
Criando um pequeno programa para lidar com um subconjunto de dados em uma estação de trabalho para um departamento específico.
Reescrever parte da lógica de negócios em JavaScript para disponibilizá-la para aplicativos front-end.

O problema com o uso direto de E/S em bibliotecas

Quando as bibliotecas usam operações IO diretamente, isso limita a reutilização da lógica da biblioteca. O uso de IO direto age como um vírus, tornando uma biblioteca inutilizável quando o sistema de IO é alterado. Isso cria a necessidade de uma solução que separe a lógica de negócios das operações de IO, permitindo que a lógica seja reutilizável e facilmente integrada a diferentes sistemas.

Perguntas sobre soluções existentes

Embora existam linguagens de programação sem efeitos colaterais e sem IO direto, como Haskell , Elm e PureScript , integrá-las aos sistemas existentes pode ser muito desafiador. Além disso, poucos programadores estão familiarizados com essas linguagens. Isso levanta duas questões importantes:

Como podemos integrar efetivamente a lógica de negócios funcional aos sistemas existentes?
Como podemos encontrar programadores que tenham conhecimento em linguagens de programação puramente funcionais?

FunctionalScript é um subconjunto puramente funcional de JavaScript projetado para fornecer componentes escaláveis e reutilizáveis para lógica de negócios. Como subconjunto, ele mantém compatibilidade futura com JavaScript, o que significa que qualquer módulo FunctionalScript pode ser usado em qualquer programa JavaScript sem nenhuma modificação. Esse recurso simplifica a integração em sistemas existentes sem exigir etapas ou ferramentas de construção adicionais. Ele permite que os programadores usem seu conhecimento JavaScript existente e conta com a familiar API JavaScript como sua biblioteca padrão.

Uma vantagem significativa do FunctionalScript em relação a outras linguagens de programação funcional é a ausência de dependência do fornecedor. FunctionalScript não tem dependências, como uma biblioteca padrão ou módulos de tempo de execução. Se o projeto FunctionalScript for abandonado, os módulos FS ainda funcionarão como módulos JavaScript regulares, garantindo a longevidade do seu código.

Além disso, JavaScript é a linguagem de programação mais popular do mundo, o que significa que os programadores não precisam aprender uma nova linguagem sofisticada para se beneficiar da programação funcional com FunctionalScript. Essa ampla familiaridade torna mais fácil encontrar e integrar desenvolvedores para trabalhar com o FunctionalScript, ajudando a enfrentar os desafios impostos por outras linguagens de programação puramente funcionais.

Tipo de sistema

FunctionalScript, como JavaScript, é uma linguagem de tipagem dinâmica . No entanto, ele se beneficia do uso de anotações de tipo TypeScript/JSDoc para ajudar a detectar a maioria dos erros de tipo. O TypeScript emprega um sistema de tipos estruturais, em oposição aos sistemas de tipos nominais encontrados em muitas linguagens modernas, como C++, Rust, C# e Java. Na prática, um sistema de tipo estrutural tende a causar menos problemas do que um sistema de tipo nominal, o que geralmente leva a adaptadores excessivos entre interfaces, prejudicando a reutilização do código.

Aqui está um exemplo que ilustra como as anotações de tipo TypeScript/JSDoc podem ser usadas no FunctionalScript:

/**
 * @template T
 * @typedef {T|undefined} Option
 */

/** @type {<T, R>(f: (value: T) => R) => (value: T|undefined) => R|undefined} */
const optionMap = f => value => value === undefined ? undefined : f(value)

// test optionMap
{
    const optionSq = optionMap(v => v * v)
    const sq3 = optionSq(3)
    if (sq3 !== 9) { throw sq3 }
    const sqUndefined = optionSq(undefined)
    if (sqUndefined !== undefined) { throw sqUndefined }
}

P: Como podemos criar aplicativos usando o FunctionalScript se ele não tiver IO?
R: É verdade que qualquer programa de trabalho requer IO. A ideia-chave por trás do FunctionalScript, no entanto, é atrasar as operações de IO o máximo possível, garantindo que a lógica de negócios principal permaneça separada das preocupações relacionadas a IO. Essa abordagem permite que a funcionalidade central seja mais reutilizável e adaptável a diferentes sistemas IO. O diagrama de dependência a seguir mostra essa estrutura:

logic.f.js

/** @typedef {(text: string) => undefined} ConsoleOut */

/** @type {(out: ConsoleOut) => undefined} */
const main = out => out('Hello world!')

module.exports = { main }

const logic = require('logic.f.js')

logic.main(console.log)

Aplicativos front-end (Web, Mobile)
Aplicativos de back-end (Node.js, Deno, Bun)
Extensões JSON para linguagens de script, como ferramentas de construção e implantação
Linguagens de consulta sofisticadas para sistemas distribuídos

Como mencionado anteriormente, o objetivo principal é ter componentes escaláveis e reutilizáveis. Os usuários que descrevem formalmente uma lógica de negócios não devem ter que reescrevê-la para um novo sistema de computação distribuída, nem devem ter que aprender uma nova linguagem de programação.

Estado atual

FunctionalScript é um projeto de código aberto lançado sob a licença MIT. O projeto ainda está em seus estágios iniciais de desenvolvimento e estamos trabalhando ativamente na criação de um analisador e outros módulos essenciais.

Todo o código é escrito em FunctionalScript, o que é uma prova das capacidades da linguagem. Depois que o analisador estiver completo, ele poderá ser usado para criar diferentes ferramentas linter e compiladores. Até então, verificamos manualmente nosso código usando FunctionalScript como uma convenção de código.