Neural Cyborg

Source Ada : 

procedure Main is
   
   type Aiborg;
   
   
   task type Learning(Ai : access Aiborg) is
      entry Halt;
   end Learning;
   
   task type Operating_System(Ai : access Aiborg) is
      entry Halt;
   end Operating_System;
   
   task type File_Manager(Ai : access Aiborg) is
      entry Halt;
   end File_Manager;
   
   task type Arch_Ai(Ai : access Aiborg) is
      entry Halt;
   end Arch_Ai;
   
   task type Borg(Ai : access Aiborg) is
      entry Halt;
   end Borg;
   
   
   
   
   
   
   type Result is abstract tagged null record;
   type Result_Access is access all Result;
   
   type Response is abstract tagged null record;
   type Response_Access is access all Respsonse;
   
   type Formal is abstract tagged null record;
   type Formal_Access is access all Formal;
      
   
   type Decider is abstract tagged null record;
      
    
   type Decider_Access is access Decider;
   
   type Normal is abstract tagged
      record
    Result : Result_Access;
    Response : Response_Access;
      end record;
    
   type Normal_Access is access Normal;
   
   type Solver is abstract tagged null record;
   type Solver_Access is access all Solver;
   
   
   type Problem is abstract tagged
      record
    Formal : Formal_Access; -- for OS;
    
    Solver : Solver_Access; -- for Borg
    
    Decider : Decider_Access; -- for Arch_Ai
    
    Normal : Normal_Access; -- for Trainner
    
      end record;
    
   
   type Problem_Access is access all Problem;
   
   
   
   
   type Neuralborg is
      record
    
    Ai       : Arch_Ai(Aiborg'Access);
    
    Trainner : Learning(Aiborg'Access);
    
    OS       : Operating_System(Aiborg'Access);
    
    Manager  : File_Manager(Aiborg'Access);    
    
    Cyborg   : Borg(Aiborg'Access);
    
    Problem  : Problem_Access;
      end record;
   
   type Neuralborg_Access is access all Neuralborg;
   
   procedure Initialize(Aiborg : in out Neuralborg_Access) is
   begin
      Aiborg.OS.Init(Aiborg.Problem.Formal);
      Aiborg.OS.Lock;
      Aiborg.Cyborg.Init(Aiborg.Problem.Solver);
      Aiborg.Manager.Init;
      Aiborg.Manager.Start;
      Aiborg.Trainner.Init(Aiborg.Problem.Normal);
      Aiborg.Trainner.Samples_Load;
      Aiborg.Trainner.Train;
      Aiborg.Ai.Init(Aiborg.Problem.Decider);
      Aiborg.Ai.Start;
      Aiborg.Os.Start;
      Aiborg.Cyborg.Start;
   end Initialize;
           
           
           
   Aiborg : Neuralborg_Access;
           
   
begin
   
      
   loop
      
      begin
    
    Aiborg := new Neuralborg_Access;
    
    declare
       
       
    begin
       
       
       
       loop
          Initialize(Aiborg);
          begin
        
        
        
        declare
           
           
           
        begin
           
           Aiborg.OS.Formalize;
           Aiborg.Ai.Decide;
           Aiborg.Cyborg.Solve;
           Aiborg.Trainner.Normalize;
           
        end;

        
        exit;
        
        
          end;
       end loop;
    end;
    
    exit;
    
      exception
    when others =>
       null;    
      end;
      
   end loop;      
   
end Main;