[elm-parse] add

Author: nojima

elm-parse/.gitignore

@@ -0,0 +1 @@
+elm-stuff/

elm-parse/elm.json

@@ -0,0 +1,26 @@
+{
+    "type": "application",
+    "source-directories": [
+        "src"
+    ],
+    "elm-version": "0.19.1",
+    "dependencies": {
+        "direct": {
+            "elm/browser": "1.0.2",
+            "elm/core": "1.0.5",
+            "elm/html": "1.0.0",
+            "elm-explorations/test": "1.2.2"
+        },
+        "indirect": {
+            "elm/json": "1.1.3",
+            "elm/random": "1.0.0",
+            "elm/time": "1.0.0",
+            "elm/url": "1.0.0",
+            "elm/virtual-dom": "1.0.2"
+        }
+    },
+    "test-dependencies": {
+        "direct": {},
+        "indirect": {}
+    }
+}

elm-parse/src/Main.elm

@@ -0,0 +1,101 @@
+module Main exposing (..)
+
+import Test exposing (Test, describe, test)
+import Expect
+
+suite : Test
+suite =
+    describe "Parser"
+        [ test "s" <|
+            \_ ->
+                let
+                    ret = parse string "hoge"
+                in
+                    Expect.equal ret ["hoge"]
+        ]
+
+{-
+import Html exposing (Html)
+
+main : Html Never
+main =
+    let
+        p = s "users"
+            |> slash string
+            |> slash (s "posts")
+            |> slash int
+            |> map Tuple.pair
+        ret = parse p "users/nojima/posts/3"
+    in
+    Html.pre []
+        [ Html.text "Hello, World"
+        , Html.text (Debug.toString ret) ]
+-}
+
+type alias Parser a b =
+    State a -> List (State b)
+
+type alias State value =
+    { tokens : List String
+    , value : value
+    }
+
+map : a -> Parser a b -> Parser (b -> c) c
+map subValue parseArg =
+    \state ->
+        parseArg { tokens = state.tokens, value = subValue }
+        |> List.map (mapState state.value)
+
+mapState : (a -> b) -> State a -> State b
+mapState func state =
+    { tokens = state.tokens, value = func state.value }
+
+tokenize : String -> List String
+tokenize str =
+    String.split "/" str
+
+parse : Parser (a -> a) a -> String -> List a
+parse parser str =
+    let
+        initialState =
+            { tokens = tokenize str
+            , value = identity
+            }
+    in
+    parser initialState
+    |> List.map (\state -> state.value)
+
+int : Parser (Int -> a) a
+int =
+    custom String.toInt
+
+string : Parser (String -> a) a
+string =
+    custom Just
+
+custom : (String -> Maybe a) -> Parser (a -> b) b
+custom stringToSomething =
+    \state ->
+        case state.tokens of
+            [] -> []
+            head :: tail ->
+                case stringToSomething head of
+                    Nothing -> []
+                    Just nextValue ->
+                        [ { tokens = tail, value = state.value nextValue } ]
+
+s : String -> Parser a a
+s str =
+    \state ->
+        case state.tokens of
+            [] -> []
+            head :: tail ->
+                if head == str
+                then [ { tokens = tail, value = state.value } ]
+                else []
+
+slash : Parser a b -> Parser b c -> Parser a c
+slash lhs rhs =
+    \state ->
+        lhs state
+        |> List.concatMap rhs

elm-parse/tests/Example.elm

@@ -0,0 +1,10 @@
+module Example exposing (..)
+
+import Expect exposing (Expectation)
+import Fuzz exposing (Fuzzer, int, list, string)
+import Test exposing (..)
+
+
+suite : Test
+suite =
+    todo "Implement our first test. See https://package.elm-lang.org/packages/elm-explorations/test/latest for how to do this!"