Haskell implementation of FastOrderLine parser

jferris · January 20, 2014, 3:04pm

This is a Haskell reimplementation of the problem posed here: http://forum.thoughtbot.com/t/balancing-negative-numbers-from-text/1700/10

The Ruby version that I’m implementing is here: Refactoring from the Weekly Iteration http://forum.thoughtbot.com/t/balancing-negative-numbers-from-text/1700/8 · GitHub

Here’s the Haskell version:

gist.github.com

https://gist.github.com/jferris/2c63e6b2b2385fa992d1

Cli.hs

import Control.Applicative ((<$>))

import Combinable (combineAll)
import LineParser (parseInput)
import Order (Order, orderWithDefaults, removeZeroQty, validate)

main :: IO ()
main = display . parse =<< getContents

parse :: String -> Either String [Order]

This file has been truncated. show original

Combinable.hs

module Combinable (Combinable, combine, combineAll, similar) where

import Data.Sequence ((<|), empty, findIndexL, fromList, Seq, adjust)
import qualified Data.Foldable as Foldable

class Combinable a where
    similar :: Combinable a => a -> a -> Bool
    combine :: Combinable a => a -> a -> a

combineAll :: Combinable a => [a] -> [a]

This file has been truncated. show original

LineParser.hs

module LineParser (parseInput) where

import Text.Regex.PCRE ((=~), getAllTextSubmatches)

parseInput :: String -> ([String] -> Maybe a) -> String -> Either String [a]
parseInput pattern parser = mapEither (parser . matchLine pattern) . lines

matchLine :: String -> String -> [String]
matchLine pattern line = tail $ getAllTextSubmatches $ line =~ pattern

This file has been truncated. show original

There are more than three files. show original

The size of the code is roughly the same as the size in Ruby, but I think a few of the constructs are pretty clean in Haskell.

I ended up defining a type class (Combinable) for this which I’m sure is already implemented somewhere in the Haskell world in some form, but I couldn’t find it. I’d be particularly interested in knowing if there’s a Category for things that can be reduced by combining some of the elements in some way; I’ve had to solve that problem a few times now.

mike-burns · January 20, 2014, 4:18pm

I wonder if MonadPlus would solve your Combinable issue. Or Monoid?

Since this is a parser, would Parsec have helped here?

jferris · January 20, 2014, 4:41pm

It definitely seems close to Monoid/MonadPlus, but there isn’t really a zero case - how would I define mempty or mzero?

I originally implemented this using Parsec. It ended up being more verbose, because I couldn’t find a good way to have it parse patterns like F12/05/20’ and return them as a single string. Because of that, I had to part out the individual parts, let bindings, and then recombine them again. Maybe there’s a better way to use Parsec? If so, that would be nice, because Parsec handles the “Error on 1: whatever” logic for you (which I implemented in LineParser).

Topic		Replies	Views
Reading group: Learn You a Haskell: Part Four Haskell	1	1118	March 7, 2014
Code snippet: find URLs that redirect and replace them with their targets Haskell	0	1195	October 25, 2013
Refactoring Fast Order Line, with Joe Ferris Ruby on Rails	16	2123	November 15, 2014
Just released a gem inspired by NullObject and thoughbot/wrapped, looking for suggestion! Ruby on Rails	5	914	December 16, 2014
Polymorphism & Ruby (blog post) Ruby on Rails	0	663	March 15, 2014

Haskell implementation of FastOrderLine parser

Related Topics