將Haskell（monadic）轉換為F＃

Question

幫我翻譯以下Haskell代碼塊。 run函數產生文本字符串，該字符串對應於抽象為Pattern的給定正則表達式。 您可以在下面的F＃代碼塊中看到Pattern類型的聲明。 您可以測試運行功能，例如

genex $ POr [PConcat [PEscape( DoPa 1) 'd'], PConcat [PEscape (DoPa 2) 'd']]

---

{-# LANGUAGE RecordWildCards, NamedFieldPuns #-}
import qualified Data.Text as T
import qualified Control.Monad.Stream as Stream
import Text.Regex.TDFA.Pattern
import Control.Monad.State
import Control.Applicative

genex = Stream.toList . run

maxRepeat :: Int
maxRepeat = 3

each = foldl1 (<|>) . map return

run :: Pattern -> Stream.Stream T.Text
run p = case p of
    PBound low high p -> do
        n <- each [low..maybe (low+maxRepeat) id high]
        fmap T.concat . sequence $ replicate n (run p) 
    PConcat ps -> fmap T.concat . Stream.suspended . sequence $ map run ps
    POr xs -> foldl1 mplus $ map run xs
    PEscape {..} -> case getPatternChar of
        'd' -> chars $ ['0'..'9']
        'w' -> chars $ ['0'..'9'] ++ '_' : ['a'..'z'] ++ ['A'..'Z']
        ch  -> isChar ch
    _      -> error $ show p
    where
    isChar = return . T.singleton
    chars = each . map T.singleton

下面，我嘗試一下。 它有效，但不正確。 問題出在下面。 假設解析產生這樣的Pattern

解析“ \\\\ d \\\\ d” ;; 值：模式= POr [PConcat [PEscape（DoPa 1，'d'）; PEscape（DoPa 2，'d'）]]

和

解析“ \\\\ d {2}” ;; 值：模式= POr [PConcat [PBound（2，Some 2，PEscape（DoPa 1，'d'））]]

因此，這兩種模式都可以運行，我希望收到seq [['2'; '2']; [ '2'; '3']; [ '2'; '1']; [ '2'; '4']; ...]對應於seq [“ 22”; “23”; “21”; “24”; ...] （每個字符串2個符號）

這在第一種情況下有效，

POr [PConcat [PEscape（DoPa 1，'d'）; PEscape（DoPa 2，'d'）]] |>運行；; val it：seq = seq [['2'; '2']; [ '2'; '3']; [ '2'; '1']; [ '2'; '4']; ...]

seq [“ 22”; “23”; “21”; “24”; ...]

但不是第二

POr [PConcat [PBound（2，Some 2，PEscape（DoPa 1，'d'））]] |>運行；; val it：seq = seq [['2']; [ '2']; [ '2']; [ '3']; ...]

seq [“ 2”; “ 2”，“ 2”; “ 3”，“ 2”; “ 1”，“ 2”； “ 4”; ...] （每個字符串1個符號）

我使用以下條款測試了不同的變體：

| POr ps                -> Seq.concat (List.map run ps)
| PConcat ps            -> (sequence (List.map (run >> Seq.concat) ps))
| PBound (low,high,p)   -> 

但都是徒勞的。 我不知道有效的翻譯。

-也許我應該使用String或Array而不是char列表。

-我認為Seq非常類似於Control.Monad.Stream。 這樣對嗎？

預先感謝您的幫助

open System

/// Used to track elements of the pattern that accept characters or are anchors
type DoPa = DoPa of int

/// Pattern is the type returned by the regular expression parser.
/// This is consumed by the CorePattern module and the tender leaves
/// are nibbled by the TNFA module.
type Pattern = PEmpty
             | POr     of Pattern list                  // flattened by starTrans
             | PConcat of Pattern list                  // flattened by starTrans
             | PBound  of int * (int option) * Pattern  // eliminated by starTrans
             | PEscape of DoPa * char                   // Backslashed Character

let maxRepeat = 3

let maybe deflt f opt = 
    match opt with
    | None -> deflt
    | Some v -> f v

/// Cartesian production
/// try in F# interactive: sequence [[1;2];[3;4]];;
let rec sequence = function 
  | []      -> Seq.singleton [] 
  | (l::ls) -> seq { for x in l do for xs in sequence ls do yield (x::xs) } 



let from'space'to'tilda     =  [' '..'~'] |> List.ofSeq
let numbers                 =  ['0'..'9'] |> List.ofSeq
let numbers'and'alphas      =  (['0'..'9'] @ '_' :: ['a'..'z'] @ ['A'..'Z']) |> List.ofSeq
let whites                  =  ['\009'; '\010'; '\012'; '\013'; '\032' ] |> List.ofSeq

let rec run (p:Pattern) : seq<char list> =
    let chars chs = seq { yield [for s in chs -> s] }
    match p with
    | POr ps                -> Seq.concat (List.map run ps)
    | PConcat ps            -> (sequence (List.map (run >> Seq.concat) ps))
    | PBound (low,high,p)   -> 
        let ns = seq {low .. maybe (low + maxRepeat) id high}
        Seq.concat (seq { for n in ns do yield  sequence (List.replicate n (((run >> Seq.concat)  p))) })
        // Seq.concat (seq { for n in ns do yield     ((List.replicate n (run p)) |> Seq.concat |> List.ofSeq |> sequence)})
        //((List.replicate low (run p)) |> Seq.concat |> List.ofSeq |> sequence)
        // PConcat [ for n in ns -> p] |> run
    | PEscape(_, ch)  -> 
        match ch with
        | 'd' -> chars numbers
        | 'w' -> chars numbers'and'alphas
        | ch  -> chars [ch]
    | _                     -> Seq.empty

Answer 1

我不知道為什么不將Haskell的Data.Text轉換為F＃中的string ，您只需要模仿兩個函數即可。 除此之外，我僅作了一些更改以使其工作，這樣您就可以輕松地將其與原始代碼進行比較，請參閱（* *）之間的替換代碼

open System

// Mimic Data.Text as T
module T =
    let concat (x:seq<_>) = System.String.Concat x
    let singleton (x:char) = string x


/// Used to track elements of the pattern that accept characters or are anchors
type DoPa = DoPa of int

/// Pattern is the type returned by the regular expression parser.
/// This is consumed by the CorePattern module and the tender leaves
/// are nibbled by the TNFA module.
type Pattern = PEmpty
             | POr     of Pattern list                  // flattened by starTrans
             | PConcat of Pattern list                  // flattened by starTrans
             | PBound  of int * (int option) * Pattern  // eliminated by starTrans
             | PEscape of DoPa * char                   // Backslashed Character

let maxRepeat = 3

let maybe deflt f opt = 
    match opt with
    | None -> deflt
    | Some v -> f v

/// Cartesian production
/// try in F# interactive: sequence [[1;2];[3;4]];;
let rec sequence = function 
  | []      -> Seq.singleton [] 
  | (l::ls) -> seq { for x in l do for xs in sequence ls do yield (x::xs) } 



let from'space'to'tilda     =  [' '..'~'] |> List.ofSeq
let numbers                 =  ['0'..'9'] |> List.ofSeq
let numbers'and'alphas      =  (['0'..'9'] @ '_' :: ['a'..'z'] @ ['A'..'Z']) |> List.ofSeq
let whites                  =  ['\009'; '\010'; '\012'; '\013'; '\032' ] |> List.ofSeq

let rec run (p:Pattern) (*: seq<char list> *) =
    (* let chars chs = seq { yield [for s in chs -> s] } *)
    let chars (chs:seq<char>)  = Seq.map string chs

    match p with
    | POr ps                -> Seq.concat (List.map run ps)
    | PConcat ps            -> Seq.map T.concat << sequence <| List.map run ps (* (sequence (List.map (run >> Seq.concat) ps)) *) 
    | PBound (low,high,p)   -> 
        seq {
        for n in [low..maybe (low+maxRepeat) id high] do
            yield! (  (Seq.map T.concat << sequence) (List.replicate n (run p)) )}
        (*let ns = seq {low .. maybe (low + maxRepeat) id high}
        Seq.concat (seq { for n in ns do yield  sequence (List.replicate n (((run >> Seq.concat)  p)))  *)

        // Seq.concat (seq { for n in ns do yield     ((List.replicate n (run p)) |> Seq.concat |> List.ofSeq |> sequence)})
        //((List.replicate low (run p)) |> Seq.concat |> List.ofSeq |> sequence)
        // PConcat [ for n in ns -> p] |> run
    | PEscape(_, ch)  -> 
        match ch with
        | 'd' -> chars numbers
        | 'w' -> chars numbers'and'alphas
        | ch  -> chars [ch]
    | _                     -> Seq.empty  

UPDATE

如果要將Haskell代碼轉換為F＃，則可以嘗試使用模仿許多Haskell函數（包括使用類型類的那些函數）的代碼 。 我做了一個盡可能接近原始Haskell代碼的測試，但是使用F＃List（不是惰性的），它看起來像這樣：

#load "Prelude.fs"
#load "Monad.fs"
#load "Applicative.fs"
#load "Monoid.fs"

open Prelude
open Control.Monad.Base
open Control.Applicative

module T =
    let concat (x:list<_>) = System.String.Concat x
    let singleton (x:char) = string x

type DoPa = DoPa of int

type Pattern = PEmpty
             | POr     of Pattern list
             | PConcat of Pattern list
             | PBound  of int * (int option) * Pattern
             | PEscape of DoPa * char

let maxRepeat = 3

let inline each   x = foldl1 (<|>) << map return'  <| x

let rec run p:list<_> = 
    let inline isChar x = return' << T.singleton   <| x
    let inline chars  x = each << map T.singleton  <| x
    match p with
    | PBound (low,high,p) -> do' {
        let! n = each [low..maybe (low+maxRepeat) id high]
        return! (fmap T.concat << sequence <| replicate n (run p))}
    | PConcat ps -> fmap T.concat << sequence <| map run ps
    | POr xs -> foldl1 mplus <| map run xs
    | PEscape (_, ch) -> 
        match ch with
        | 'd' -> chars <| ['0'..'9']
        | 'w' -> chars <| ['0'..'9'] @ '_' :: ['a'..'z'] @ ['A'..'Z']
        | ch  -> isChar ch
    | _  -> failwith <| string p

let genex = run