实现Parser Functor [英] Implementing Parser Functor

问题描述

在Brent Yorgey的2013 UPenn上工作课程作业，以下 newtype 存在：

newtype Parser a = Parser {runParser ::字符串 - >可能（a，字符串）}

我试图将 Parser a Functor 。

给出以下第一个函数帮助解决这个问题：

  first ::（a  - > b） - > （a，c） - > （b，c）
 first f（a，c）=（fa，c）
  

 实例Functor（Parser）其中
 fmap g（Parser f）= Parser $ fmap （第一克）（f。g）
  

然而，这是行不通的。

据我所知， f 的类型是 String - >也许（a，字符串）。所以，我不知道如何应用 a 字符串到 f 为了得到 Maybe（a，String）。

一旦我得到 Maybe（a，String），我相信我可以简单地运行 fmap（first g）... 其中 ... 表示也许。

请给我一个提示如何获取 Maybe（a，String）。

既然 f 欠了 String 类型 Maybe（a，String），我不知道在哪里找到 String 参数。

解决方案

你做得很好。

如果我只是创建一个类型同义词，它可能会更清晰

 键入M a = Maybe（a，String）
  

你是对的，你可以使用

  fmap（first g）:: Maybe（a，String） - >也许（b，字符串）
  -  :: M a  - > M b 
  

并将它与

  f :: String  - >也许（a，字符串）
  - 字符串 - > M a 
  

您只需撰写字符串 - > M a 与 M a - > M b 得到字符串 - > M b ：

  instance Functor（Parser）where 
 fmap g（Parser f） =解析器$ fmap（第一个g）。 f 
  

---

你问是否可以得到一个String某处。 Lambda会为你做这件事： \xs - > 可以被读取为给我一个字符串 xs .. 。，并且您可以将 f 应用于该字符串以获取 Maybe（a，String）类型的内容。所以你也可以这样写：

pre $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ \\ xs - > fmap（first g）（f xs）

Working on Brent Yorgey's 2013 UPenn class homework, the following newtype exists:

newtype Parser a = Parser { runParser :: String -> Maybe (a, String) }

I'm trying to implement Parser as a Functor.

Given the following first function to help with this problem:

first :: (a -> b) -> (a, c) -> (b, c)
first f (a, c) = (f a, c) 

I tried the following:

instance Functor (Parser) where
  fmap g (Parser f)  = Parser $ fmap (first g) (f . g)

However, that doesn't work.

As I understand, f's type is String -> Maybe (a, String). So, I don't know how to apply a String to f in order to get Maybe (a, String).

Once I get a Maybe (a, String), I believe that I can simply run fmap (first g) ... where ... represents the Maybe.

Please give me a hint to understand how to get the Maybe (a, String).

Since f is owed a String to give a type of Maybe (a, String), I don't know where to find that String argument.

解决方案

You're doing great.

If I just make a type synonym it might be clearer

type M a = Maybe (a,String)

You're right that you can use

fmap (first g) :: Maybe (a, String) -> Maybe (b,String)
--             :: M a -> M b

and combine it with

f :: String -> Maybe (a,String)
--   String -> M a

You just need to compose String -> M a with M a -> M b to get String -> M b:

instance Functor (Parser) where
  fmap g (Parser f)  = Parser $ fmap (first g) . f

---

You asked if you could get a String from somewhere. Lambda will do that for you: \xs -> can be read "give me a String xs...", and you could apply f to that String to get something of type Maybe (a,String). So you could also write:

instance Functor (Parser) where
  fmap g (Parser f)  = Parser $ \xs -> fmap (first g) (f xs)

这篇关于实现Parser Functor的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！