Как взять список вывода функции в качестве входных данных для другой функции в Haskell?

Question

Допустим, у нас есть функция truthtable ::BoolExpr -> [([Variable], Bool)], которая возвращает значение в списке упорядоченных пар переменной и ее оценку Bool.

функции определены следующим образом

module BoolExpr (Variable, BoolExpr(..), evaluate) where
import Data.List
import System.IO

type Variable = Char
data BoolExpr = T
 |F
 |Var Variable
 |Not BoolExpr
 |And BoolExpr BoolExpr
 |Or BoolExpr BoolExpr
 deriving(Show)


-- evaluates an expression
evaluate :: BoolExpr -> [Variable] -> Bool
evaluate T _            = True
evaluate F _            = False
evaluate (Var v) vs     = v `elem` vs
evaluate (Not e) vs     = not (evaluate e vs)
evaluate (And e1 e2) vs = evaluate e1 vs && evaluate e2 vs
evaluate (Or  e1 e2) vs = evaluate e1 vs || evaluate e2 vs

--remove duplicates
rmdups :: (Ord a) => [a] -> [a]
rmdups = map head . group . sort


variables :: BoolExpr -> [Variable]
variables T = []
variables F = []
variables (Var e1) = [e1]
variables (And e1 e2) =rmdups$ sort $ variables e1 ++ variables e2
variables (Or e1 e2) =rmdups$ sort $ variables e1 ++ variables e2
variables (Not e) = variables e



 --function to get the subsets of a list
subsets :: [Variable] -> [[Variable]]
subsets [] = [[]]
subsets (x:xs) = [zs | ys <- subsets xs, zs <- [ys, (x:ys)]]

Теперь подмножества функций возвращают все возможные подмножества в строке, например.

> subsets "abc"
["","c","b","bc","a","ac","ab","abc"]

Теперь, как взять каждый элемент в этом списке и поместить его здесь

evaluate (And (Var 'a') (Or (Var 'c') (Var 'b'))) "HERE"

Я знаю, как сделать что-то подобное в C, используя итерацию по списку и делая вычисления.

Мой подход: количество подмножеств строки = 2 ^ n где n - количество элементов

. Теперь я бы использовал такой сценарий:

let x=0
iterate form x to (n-1) (subsets $ variables (And e1 e2)) !! x

Я знаю, что оператор !! позволяет выбирать элемент из списка в соответствии с индексом. написано. Наконец, результат вышеупомянутого блока применяется к функции evaluate в конечной части ЗДЕСЬ. что то, что функция truthtable оценивает в целом

> truthtable (And (Var 'a') (Or (Var 'c') (Var 'b')))

[("",False),("c",False),("b",False),("bc",False),("a",False),("ac",True),("ab",True),("abc",True)]

любые идеи, как применить это в Haskell

Answer 1

Теперь, как взять каждый элемент в этом списке и поместить его здесь

evaluate (And (Var 'a') (Or (Var 'c') (Var 'b'))) "HERE"

Вот так:

map (evaluate (And ...)) (subsets "abc")

Answer 2

> truthtable (And (Var 'a') (Or (Var 'c') (Var 'b')))

[("",False),("c",False),("b",False), ...

Вы имеете в виду,

truthtable expr =
            [ evaluate expr s | s <- subsets (variables expr) ]
{-
 expr ::               BoolExpr
 variables ::          BoolExpr -> [Variable]
 variables expr ::                 [Variable]
 subsets ::                        [Variable] -> [[Variable]]
 subsets (variables expr) ::                     [[Variable]]
 s ::                                             [Variable]
 evaluate ::           BoolExpr                -> [Variable]  ->  Bool
 evaluate              expr                       s           ::  Bool
[evaluate              expr                       s         ] :: [Bool]
-----------------------------------------------------------------------
truthtable ::          BoolExpr                               -> [Bool]
-}

Синтаксис [ foo | x <- xs ] известен как "понимание списка" .

Это аналог петле в императивной парадигме и может читаться как "список foo s, для x вxs ". Это также эквивалентно map (\ x -> foo ) xs;также

  [ foo | x <- [a, b, c] ]
=
  [ foo | x <- [a]   ++              [b]   ++              [c] ]
=
  [ foo | x <- [a] ] ++ [ foo | x <- [b] ] ++ [ foo | x <- [c] ]
=
  [ foo | let x=a  ] ++ [ foo | let x=b  ] ++ [ foo | let x=c  ]

:: означает "имеет тип" .