elm-rails 0.1.2 → 0.2.0

data/test/rails4.2/elm-stuff/packages/elm-lang/core/5.0.0/src/Result.elm

@@ -0,0 +1,210 @@
+module Result exposing
+  ( Result(..)
+  , withDefault
+  , map, map2, map3, map4, map5
+  , andThen
+  , toMaybe, fromMaybe, mapError
+  )
+
+{-| A `Result` is the result of a computation that may fail. This is a great
+way to manage errors in Elm.
+
+# Type and Constructors
+@docs Result
+
+# Mapping
+@docs map, map2, map3, map4, map5
+
+# Chaining
+@docs andThen
+
+# Handling Errors
+@docs withDefault, toMaybe, fromMaybe, mapError
+-}
+
+import Maybe exposing ( Maybe(Just, Nothing) )
+
+
+{-| A `Result` is either `Ok` meaning the computation succeeded, or it is an
+`Err` meaning that there was some failure.
+-}
+type Result error value
+    = Ok value
+    | Err error
+
+
+{-| If the result is `Ok` return the value, but if the result is an `Err` then
+return a given default value. The following examples try to parse integers.
+
+    Result.withDefault 0 (String.toInt "123") == 123
+    Result.withDefault 0 (String.toInt "abc") == 0
+-}
+withDefault : a -> Result x a -> a
+withDefault def result =
+  case result of
+    Ok a ->
+        a
+
+    Err _ ->
+        def
+
+
+{-| Apply a function to a result. If the result is `Ok`, it will be converted.
+If the result is an `Err`, the same error value will propagate through.
+
+    map sqrt (Ok 4.0)          == Ok 2.0
+    map sqrt (Err "bad input") == Err "bad input"
+-}
+map : (a -> value) -> Result x a -> Result x value
+map func ra =
+    case ra of
+      Ok a -> Ok (func a)
+      Err e -> Err e
+
+
+{-| Apply a function to two results, if both results are `Ok`. If not,
+the first argument which is an `Err` will propagate through.
+
+    map2 (+) (String.toInt "1") (String.toInt "2") == Ok 3
+    map2 (+) (String.toInt "1") (String.toInt "y") == Err "could not convert string 'y' to an Int"
+    map2 (+) (String.toInt "x") (String.toInt "y") == Err "could not convert string 'x' to an Int"
+-}
+map2 : (a -> b -> value) -> Result x a -> Result x b -> Result x value
+map2 func ra rb =
+    case (ra,rb) of
+      (Ok a, Ok b) -> Ok (func a b)
+      (Err x, _) -> Err x
+      (_, Err x) -> Err x
+
+
+{-|-}
+map3 : (a -> b -> c -> value) -> Result x a -> Result x b -> Result x c -> Result x value
+map3 func ra rb rc =
+    case (ra,rb,rc) of
+      (Ok a, Ok b, Ok c) -> Ok (func a b c)
+      (Err x, _, _) -> Err x
+      (_, Err x, _) -> Err x
+      (_, _, Err x) -> Err x
+
+
+{-|-}
+map4 : (a -> b -> c -> d -> value) -> Result x a -> Result x b -> Result x c -> Result x d -> Result x value
+map4 func ra rb rc rd =
+    case (ra,rb,rc,rd) of
+      (Ok a, Ok b, Ok c, Ok d) -> Ok (func a b c d)
+      (Err x, _, _, _) -> Err x
+      (_, Err x, _, _) -> Err x
+      (_, _, Err x, _) -> Err x
+      (_, _, _, Err x) -> Err x
+
+
+{-|-}
+map5 : (a -> b -> c -> d -> e -> value) -> Result x a -> Result x b -> Result x c -> Result x d -> Result x e -> Result x value
+map5 func ra rb rc rd re =
+    case (ra,rb,rc,rd,re) of
+      (Ok a, Ok b, Ok c, Ok d, Ok e) -> Ok (func a b c d e)
+      (Err x, _, _, _, _) -> Err x
+      (_, Err x, _, _, _) -> Err x
+      (_, _, Err x, _, _) -> Err x
+      (_, _, _, Err x, _) -> Err x
+      (_, _, _, _, Err x) -> Err x
+
+
+{-| Chain together a sequence of computations that may fail. It is helpful
+to see its definition:
+
+    andThen : (a -> Result e b) -> Result e a -> Result e b
+    andThen callback result =
+        case result of
+          Ok value -> callback value
+          Err msg -> Err msg
+
+This means we only continue with the callback if things are going well. For
+example, say you need to use (`toInt : String -> Result String Int`) to parse
+a month and make sure it is between 1 and 12:
+
+    toValidMonth : Int -> Result String Int
+    toValidMonth month =
+        if month >= 1 && month <= 12
+            then Ok month
+            else Err "months must be between 1 and 12"
+
+    toMonth : String -> Result String Int
+    toMonth rawString =
+        toInt rawString
+          |> andThen toValidMonth
+
+    -- toMonth "4" == Ok 4
+    -- toMonth "9" == Ok 9
+    -- toMonth "a" == Err "cannot parse to an Int"
+    -- toMonth "0" == Err "months must be between 1 and 12"
+
+This allows us to come out of a chain of operations with quite a specific error
+message. It is often best to create a custom type that explicitly represents
+the exact ways your computation may fail. This way it is easy to handle in your
+code.
+-}
+andThen : (a -> Result x b) -> Result x a -> Result x b
+andThen callback result =
+    case result of
+      Ok value ->
+        callback value
+
+      Err msg ->
+        Err msg
+
+
+{-| Transform an `Err` value. For example, say the errors we get have too much
+information:
+
+    parseInt : String -> Result ParseError Int
+
+    type alias ParseError =
+        { message : String
+        , code : Int
+        , position : (Int,Int)
+        }
+
+    mapError .message (parseInt "123") == Ok 123
+    mapError .message (parseInt "abc") == Err "char 'a' is not a number"
+-}
+mapError : (x -> y) -> Result x a -> Result y a
+mapError f result =
+    case result of
+      Ok v ->
+        Ok v
+
+      Err e ->
+        Err (f e)
+
+
+{-| Convert to a simpler `Maybe` if the actual error message is not needed or
+you need to interact with some code that primarily uses maybes.
+
+    parseInt : String -> Result ParseError Int
+
+    maybeParseInt : String -> Maybe Int
+    maybeParseInt string =
+        toMaybe (parseInt string)
+-}
+toMaybe : Result x a -> Maybe a
+toMaybe result =
+    case result of
+      Ok  v -> Just v
+      Err _ -> Nothing
+
+
+{-| Convert from a simple `Maybe` to interact with some code that primarily
+uses `Results`.
+
+    parseInt : String -> Maybe Int
+
+    resultParseInt : String -> Result String Int
+    resultParseInt string =
+        fromMaybe ("error parsing string: " ++ toString string) (parseInt string)
+-}
+fromMaybe : x -> Maybe a -> Result x a
+fromMaybe err maybe =
+    case maybe of
+      Just v  -> Ok v
+      Nothing -> Err err

data/test/rails4.2/elm-stuff/packages/elm-lang/core/5.0.0/src/Set.elm

@@ -0,0 +1,168 @@
+module Set exposing
+  ( Set
+  , empty, singleton, insert, remove
+  , isEmpty, member, size
+  , foldl, foldr, map
+  , filter, partition
+  , union, intersect, diff
+  , toList, fromList
+  )
+
+{-| A set of unique values. The values can be any comparable type. This
+includes `Int`, `Float`, `Time`, `Char`, `String`, and tuples or lists
+of comparable types.
+
+Insert, remove, and query operations all take *O(log n)* time.
+
+# Sets
+@docs Set
+
+# Build
+@docs empty, singleton, insert, remove
+
+# Query
+@docs isEmpty, member, size
+
+# Combine
+@docs union, intersect, diff
+
+# Lists
+@docs toList, fromList
+
+# Transform
+@docs map, foldl, foldr, filter, partition
+
+-}
+
+import Basics exposing ((<|))
+import Dict as Dict
+import List as List
+
+
+{-| Represents a set of unique values. So `(Set Int)` is a set of integers and
+`(Set String)` is a set of strings.
+-}
+type Set t =
+  Set_elm_builtin (Dict.Dict t ())
+
+
+{-| Create an empty set.
+-}
+empty : Set a
+empty =
+  Set_elm_builtin Dict.empty
+
+
+{-| Create a set with one value.
+-}
+singleton : comparable -> Set comparable
+singleton k =
+  Set_elm_builtin <| Dict.singleton k ()
+
+
+{-| Insert a value into a set.
+-}
+insert : comparable -> Set comparable -> Set comparable
+insert k (Set_elm_builtin d) =
+  Set_elm_builtin <| Dict.insert k () d
+
+
+{-| Remove a value from a set. If the value is not found, no changes are made.
+-}
+remove : comparable -> Set comparable -> Set comparable
+remove k (Set_elm_builtin d) =
+  Set_elm_builtin <| Dict.remove k d
+
+
+{-| Determine if a set is empty.
+-}
+isEmpty : Set a -> Bool
+isEmpty (Set_elm_builtin d) =
+  Dict.isEmpty d
+
+
+{-| Determine if a value is in a set.
+-}
+member : comparable -> Set comparable -> Bool
+member k (Set_elm_builtin d) =
+  Dict.member k d
+
+
+{-| Determine the number of elements in a set.
+-}
+size : Set a -> Int
+size (Set_elm_builtin d) =
+  Dict.size d
+
+
+{-| Get the union of two sets. Keep all values.
+-}
+union : Set comparable -> Set comparable -> Set comparable
+union (Set_elm_builtin d1) (Set_elm_builtin d2) =
+  Set_elm_builtin <| Dict.union d1 d2
+
+
+{-| Get the intersection of two sets. Keeps values that appear in both sets.
+-}
+intersect : Set comparable -> Set comparable -> Set comparable
+intersect (Set_elm_builtin d1) (Set_elm_builtin d2) =
+  Set_elm_builtin <| Dict.intersect d1 d2
+
+
+{-| Get the difference between the first set and the second. Keeps values
+that do not appear in the second set.
+-}
+diff : Set comparable -> Set comparable -> Set comparable
+diff (Set_elm_builtin d1) (Set_elm_builtin d2) =
+  Set_elm_builtin <| Dict.diff d1 d2
+
+
+{-| Convert a set into a list, sorted from lowest to highest.
+-}
+toList : Set comparable -> List comparable
+toList (Set_elm_builtin d) =
+  Dict.keys d
+
+
+{-| Convert a list into a set, removing any duplicates.
+-}
+fromList : List comparable -> Set comparable
+fromList xs = List.foldl insert empty xs
+
+
+{-| Fold over the values in a set, in order from lowest to highest.
+-}
+foldl : (comparable -> b -> b) -> b -> Set comparable -> b
+foldl f b (Set_elm_builtin d) =
+  Dict.foldl (\k _ b -> f k b) b d
+
+
+{-| Fold over the values in a set, in order from highest to lowest.
+-}
+foldr : (comparable -> b -> b) -> b -> Set comparable -> b
+foldr f b (Set_elm_builtin d) =
+  Dict.foldr (\k _ b -> f k b) b d
+
+
+{-| Map a function onto a set, creating a new set with no duplicates.
+-}
+map : (comparable -> comparable2) -> Set comparable -> Set comparable2
+map f s = fromList (List.map f (toList s))
+
+
+{-| Create a new set consisting only of elements which satisfy a predicate.
+-}
+filter : (comparable -> Bool) -> Set comparable -> Set comparable
+filter p (Set_elm_builtin d) =
+  Set_elm_builtin <| Dict.filter (\k _ -> p k) d
+
+
+{-| Create two new sets; the first consisting of elements which satisfy a
+predicate, the second consisting of elements which do not.
+-}
+partition : (comparable -> Bool) -> Set comparable -> (Set comparable, Set comparable)
+partition p (Set_elm_builtin d) =
+  let
+    (p1, p2) = Dict.partition (\k _ -> p k) d
+  in
+    (Set_elm_builtin p1, Set_elm_builtin p2)