grule rule engine

"Gopher mantém as regras"

Grule-Rule-Motor

 import "github.com/hyperjumptech/grule-rule-engine" 

Mecanismo de regras para Go

Grule é uma biblioteca Rule Engine para a linguagem de programação Go (Golang). Inspirado no aclamado JBOSS Drools e feito de uma forma muito mais simples.

Assim como o Drools , o Grule possui sua própria DSL ou linguagem específica de domínio.

Abaixo está um exemplo de DRL ou Drools Rule Language do Drools:

 rule "SpeedUp"
    salience 10
    when
        $TestCar : TestCarClass( speedUp == true && speed < maxSpeed )
        $DistanceRecord : DistanceRecordClass()
    then
        $TestCar.setSpeed($TestCar.Speed + $TestCar.SpeedIncrement);
        update($TestCar);
        $DistanceRecord.setTotalDistance($DistanceRecord.getTotalDistance() + $TestCar.Speed);
        update($DistanceRecord);
end

O GRL de Grule é o seguinte:

 rule SpeedUp "When testcar is speeding up we keep increase the speed." salience 10  {
    when
        TestCar . SpeedUp == true && TestCar . Speed < TestCar . MaxSpeed
    then
        TestCar . Speed = TestCar . Speed + TestCar . SpeedIncrement ;
        DistanceRecord . TotalDistance = DistanceRecord . TotalDistance + TestCar . Speed ;
}

O que é um mecanismo de regras

Não há explicação melhor do que o artigo de autoria de Martin Fowler. Você pode ler o artigo aqui (RulesEngine de Martin Fowler).

Retirado do site TutorialsPoint (com pequenas modificações),

O Grule Rule Engine é um sistema de regras de produção que usa a abordagem baseada em regras para implementar um sistema especialista. Sistemas Especialistas são sistemas baseados em conhecimento que usam representações de conhecimento para processar o conhecimento adquirido em uma base de conhecimento que pode ser usada para raciocínio.

Um Sistema de Regras de Produção é Turing completo com foco na representação do conhecimento para expressar lógica proposicional e de primeira ordem de maneira concisa, não ambígua e declarativa.

O cérebro de um Sistema de Regras de Produção é um mecanismo de inferência que pode ser dimensionado para um grande número de regras e fatos. O Motor de Inferência compara fatos e dados com Regras de Produção – também chamadas de Produções ou apenas Regras – para inferir conclusões que resultam em ações.

Uma regra de produção é uma estrutura de duas partes que usa lógica de primeira ordem para raciocinar sobre a representação do conhecimento. Um mecanismo de regras de negócios é um sistema de software que executa uma ou mais regras de negócios em um ambiente de produção em tempo de execução.

Um mecanismo de regras permite definir “O que fazer” e não “Como fazer”.

O que é uma regra

(também retirado de TutorialsPoint)

Regras são conhecimentos frequentemente expressos como: "Quando ocorrerem algumas condições, execute algumas tarefas."

 When
   < Condition is true >
Then
   < Take desired Action >

A parte mais importante de uma regra é a parte quando. Se a parte when for satisfeita, a parte then será acionada.

 rule  < rule_name > < rule_description >
   < attribute > < value > {
   when
      < conditions >

   then
      < actions >
}

Vantagens de um mecanismo de regras

Programação Declarativa

As regras facilitam a expressão de soluções para problemas difíceis e também a obtenção de verificações. Ao contrário do código, as regras são escritas com uma linguagem menos complexa; Os analistas de negócios podem ler e verificar facilmente um conjunto de regras.

Lógica e Separação de Dados

Os dados residem nos Objetos de Domínio e a lógica de negócios reside nas Regras. Dependendo do tipo de projeto, esse tipo de separação pode ser muito vantajoso.

Centralização do Conhecimento

Ao usar Regras, você cria um repositório de conhecimento (uma base de conhecimento) que é executável. É um único ponto de verdade para a política empresarial. Idealmente, as Regras são tão legíveis que também podem servir como documentação.

Agilidade para mudar

Já que as regras de negócios são, na verdade, tratadas como dados. Ajustar a regra de acordo com a natureza dinâmica do negócio torna-se trivial. Não há necessidade de reconstruir código ou implantar como faz o desenvolvimento normal de software - você só precisa implementar conjuntos de regras e aplicá-los ao repositório de conhecimento.

Casos de uso

Os seguintes casos são melhor resolvidos com um mecanismo de regras:

1. Um sistema especialista que deve avaliar fatos para fornecer algum tipo de conclusão do mundo real. Se não fosse usado um mecanismo de regras no estilo RETE, seria possível codificar um conjunto em cascata de instruções if / else , e as permutações das combinações de como elas poderiam ser avaliadas se tornariam rapidamente impossíveis de gerenciar. Um mecanismo de regras baseado em tabela pode ser suficiente, mas ainda é mais frágil contra mudanças e não é muito fácil de codificar. Um sistema como o Grule permite que você descreva as regras e os fatos do seu sistema, liberando você da necessidade de descrever como as regras são avaliadas em relação a esses fatos e escondendo de você a maior parte dessa complexidade.

2. Um sistema de classificação. Por exemplo, um sistema bancário pode querer criar uma “pontuação” para cada cliente com base nos registros de transações (fatos) do cliente. Poderíamos ver a mudança de sua pontuação com base na frequência com que interagem com o banco, quanto dinheiro transferem e transferem, com que rapidez pagam suas contas, quantos juros acumulam, quanto ganham para si ou para o banco e breve. Um mecanismo de regras pode ser fornecido por um desenvolvedor, e a especificação dos fatos e das regras pode então ser fornecida por especialistas no assunto do departamento de análise de clientes do banco. A dissociação destas diferentes equipas coloca as responsabilidades onde deveriam estar.

3. Jogos de computador. O status do jogador, recompensas, penalidades, danos, pontuações e sistemas de probabilidade são muitos exemplos diferentes de onde as regras desempenham um papel significativo na maioria dos jogos de computador. Essas regras podem interagir de maneiras muito complexas, muitas vezes de maneiras que o desenvolvedor não previu. Codificar essas situações dinâmicas através do uso de uma linguagem de script (por exemplo, Lua) pode ser bastante complexo, e um mecanismo de regras pode ajudar a simplificar tremendamente o trabalho.

4. Sistemas de classificação. Na verdade, esta é uma generalização do sistema de classificação descrito acima. Usando um mecanismo de regras, podemos classificar coisas como elegibilidade de crédito, identificação bioquímica, avaliação de risco para produtos de seguros, ameaças potenciais à segurança e muito mais.

5. Sistema de aconselhamento/sugestão. Uma “regra” é simplesmente outro tipo de dado, o que a torna uma excelente candidata para definição por outro programa. Este programa pode ser outro sistema especialista ou inteligência artificial. As regras podem ser manipuladas por outros sistemas para lidar com novos tipos de fatos ou informações recém-descobertas sobre o domínio que o conjunto de regras pretende modelar.

Existem muitos outros casos de uso que se beneficiariam com o uso de um Rule-Engine. Os casos acima representam apenas um pequeno número dos casos potenciais.

No entanto, é importante lembrar que um Rule-Engine não é uma solução mágica, é claro. Existem muitas alternativas para resolver problemas de “conhecimento” em software, e estas devem ser empregadas onde forem mais apropriadas. Não se empregaria um mecanismo de regras onde uma simples ramificação if / else seria suficiente, por exemplo.

Há outra coisa a ser observada: algumas implementações de mecanismos de regras são extremamente caras, mas muitas empresas ganham tanto valor com elas que o custo de executá-las é facilmente compensado por esse valor. Mesmo para casos de uso moderadamente complexos, o benefício de um mecanismo de regras forte que pode dissociar equipes e controlar a complexidade do negócio parece ser bastante claro.

Documentos

Página de documentação aqui

Para mergulhar no Tutorial, consulte o Wiki Docs aqui no Github.

Referência

Loading rules into KnowledgeBase :

• Para carregar 100 regras no KnowledgeBase foram necessários 99342047 ns/op (assumiu o valor mais alto) que é igual a ~99.342047ms e ( 49295906 B/op ) ~49.295906MB de memória por operação

• Para carregar 1000 regras no KnowledgeBase foram necessários 933617752 ns/op (assumiu o valor mais alto) que é igual a ~933.617752ms e ( 488126636 B/op ) ~488.126636 memória por operação

Executing rules against a fact :

• Para executar um fato contra 100 regras, o Grule Engine pegou ~9697 ns/op (tomou o valor mais alto como base) que dificilmente é ~0.009697ms e 3957 B/op , o que é bastante rápido.

• Para executar um fato contra 1000 regras, o Grule Engine pegou ~568959 ns/op (tomou o valor mais alto como base) que dificilmente é ~0.568959ms e 293710 B/op , o que também é bastante rápido.

Você pode ler o relatório detalhado aqui

Tarefas e ajuda necessária

Sim. Precisamos de contribuidores para tornar o Grule ainda melhor e útil para a comunidade Open Source.

• Precisa fazer cada vez mais e mais testes.
• Melhor teste de cobertura de código.
• Melhor comentar sobre as melhores práticas do go doc.
• Melhore o tratamento de argumentos de função para ser mais fluido e intuitivo.

Se você realmente deseja nos ajudar, basta Fork o projeto e solicitar Pull Request. Por favor, leia nosso Manual de Contribuição e Código de Conduta