Функциональные языки в разработке аппаратуры09.12.2016 20:33

delay = 0:

(:) — конструктор списка. Создает новый список, добавляя к старому в начало один элемент.

0 : [1,2,3,4,5]

zip — превращает два списка в список пар.

zip [1,2,3,4] "1234"

[(1,'1'),(2,'2'),(3,'3'),(4,'4')]

zipWith применяет функцию к элементам из двух списков

zipWith (+) [1,2,3,4] [1,3,5,7]

zip = zipWith (,)

zip3 и zipWith3 работают аналогично, но для трех списков.

scanl применяет функцию к каждому элементу списка «с накоплением». Его тип (сигнатура) описывается так:

scanl :: (b -> a -> b) -> b -> [a] -> [b]

scanl (+) 0 [1,2,3,4]

($) — постфиксная запись применения функции к аргументу.

f $ x = f x

Запись \x y → f y x означает анонимную функцию (еще называемую замыканием) с параметрами x и y.

Дальше встретится несколько непонятных терминов. Я надеюсь, они не испугают читателя. Даже если это описание будет слишком сложным, по примерам будет легко разобраться, как эти функции используются.

fmap — «поднимает» функцию от отдельной величины до функции над целым контейнером. Контейнер должен быть функтором, но почти все им является. В частности такими контейнерами являются сигналы, хранящие значения для каждого момента времени. Так же такими контейнерами являются списки, хотя для них, по историческим причинам, есть специальная функция «map» с той же функциональностью.
liftA — то же самое, что fmap, но для аппликативных функторов (о чем свидетельствует буква 'A' в названии). Сигналы так же являются аппликативными функторами, а со списками все сложнее. Формально списки тоже аппликативные функторы и liftA с ними работает ожидаемым образом. Но liftA2 и liftA3 ведут себя неожиданно, но это тема для отдельной статьи.

liftA2 и liftA3 «поднимают» функции от двух и трех аргументов до функций от контейнеров. Они будут работать с сигналами, а для списков лучше использовать zipWith и zipWith3.

module ADD1 where

import CLaSH.Prelude

topEntity :: Signal (Bool, Bool) -> Signal (Bool, Bool)
topEntity = fmap (\(s1,s2) -> (s1 .&. s2, s1 `xor` s2))

// Automatically generated Verilog-2001
module ADD1_topEntity_0(a1
                       ,result);
  input [1:0] a1;
  output [1:0] result;
  wire [0:0] app_arg;
  wire [0:0] case_alt;
  wire [0:0] app_arg_0;
  wire [1:0] case_alt_0;
  wire [0:0] s1;
  wire [0:0] s2;
  assign app_arg = s1 & s2;

  reg [0:0] case_alt_reg;
  always @(*) begin
    if(s2)
      case_alt_reg = 1'b0;
    else
      case_alt_reg = 1'b1;
  end
  assign case_alt = case_alt_reg;

  reg [0:0] app_arg_0_reg;
  always @(*) begin
    if(s1)
      app_arg_0_reg = case_alt;
    else
      app_arg_0_reg = s2;
  end
  assign app_arg_0 = app_arg_0_reg;

  assign case_alt_0 = {app_arg
                      ,app_arg_0};

  assign s1 = a1[1:1];

  assign s2 = a1[0:0];

  assign result = case_alt_0;
endmodule

// Automatically generated SystemVerilog-2005
module DIV3Moore_moore(w3
                      ,// clock
                      system1000
                      ,// asynchronous reset: active low
                      system1000_rstn
                      ,result);
  input logic [0:0] w3;
  input logic system1000;
  input logic system1000_rstn;
  output logic [0:0] result;
  logic [1:0] s1_app_arg;
  logic [1:0] s1;
  always_comb begin
    case(s1)
      2'b00 : s1_app_arg = 2'd1;
      2'b01 : s1_app_arg = 2'd2;
      default : s1_app_arg = 2'd0;
    endcase
  end

  // register begin
  logic [1:0] dout;

  always_ff @(posedge system1000 or negedge system1000_rstn) begin : DIV3Moore_moore_register
    if (~ system1000_rstn) begin
      dout <= 2'd0;
    end else begin
      dout <= s1_app_arg;
    end
  end

  assign s1 = dout;
  // register end

  always_comb begin
    case(s1)
      2'b10 : result = 1'b1;
      default : result = 1'b0;
    endcase
  end
endmodule

-- Automatically generated VHDL-93
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.NUMERIC_STD.ALL;
use IEEE.MATH_REAL.ALL;
use std.textio.all;
use work.all;
use work.div3mealy_types.all;

entity div3mealy_mealy is
  port(w2              : in boolean;
       -- clock
       system1000      : in std_logic;
       -- asynchronous reset: active low
       system1000_rstn : in std_logic;
       result          : out boolean);
end;

architecture structural of div3mealy_mealy is
  signal y         : boolean;
  signal result_0  : div3mealy_types.tup2;
  signal x         : unsigned(1 downto 0);
  signal x_app_arg : unsigned(1 downto 0);
  signal x_0       : unsigned(1 downto 0);
begin
  result <= y;

  y <= result_0.tup2_sel1;

  with (x) select
    result_0 <= (tup2_sel0 => to_unsigned(1
                                         ,2)
                ,tup2_sel1 => false) when "00",
                (tup2_sel0 => to_unsigned(2,2)
                ,tup2_sel1 => false) when "01",
                (tup2_sel0 => to_unsigned(0,2)
                ,tup2_sel1 => true) when others;

  -- register begin
  div3mealy_mealy_register : process(system1000,system1000_rstn)
  begin
    if system1000_rstn = '0' then
      x <= to_unsigned(0,2);
    elsif rising_edge(system1000) then
      x <= x_app_arg;
    end if;
  end process;
  -- register end

  x_app_arg <= x_0;

  x_0 <= result_0.tup2_sel0;
end;