elm-rails 0.2.0 → 0.2.1

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

@@ -1,148 +0,0 @@
-module Regex exposing
-  ( Regex
-  , regex, escape, caseInsensitive
-  , HowMany(..), Match
-  , contains, find, replace, split
-  )
-
-{-| A library for working with regular expressions. It uses [the
-same kind of regular expressions accepted by JavaScript](https://developer.mozilla.org/en/docs/Web/JavaScript/Guide/Regular_Expressions).
-
-# Create
-@docs Regex, regex, escape, caseInsensitive
-
-# Helpful Data Structures
-
-These data structures are needed to help define functions like [`find`](#find)
-and [`replace`](#replace).
-
-@docs HowMany, Match
-
-# Use
-@docs contains, find, replace, split
-
--}
-
-import Maybe exposing (Maybe)
-import Native.Regex
-
-
-{-| A regular expression, describing a certain set of strings.
--}
-type Regex = Regex
-
-
-{-| Escape strings to be regular expressions, making all special characters
-safe. So `regex (escape "^a+")` will match exactly `"^a+"` instead of a series
-of `a`’s that start at the beginning of the line.
--}
-escape : String -> String
-escape =
-  Native.Regex.escape
-
-
-{-| Create a Regex that matches patterns [as specified in JavaScript](https://developer.mozilla.org/en/docs/Web/JavaScript/Guide/Regular_Expressions#Writing_a_Regular_Expression_Pattern).
-
-Be careful to escape backslashes properly! For example, `"\w"` is escaping the
-letter `w` which is probably not what you want. You probably want `"\\w"`
-instead, which escapes the backslash.
--}
-regex : String -> Regex
-regex =
-  Native.Regex.regex
-
-
-
-{-| Make a regex case insensitive -}
-caseInsensitive : Regex -> Regex
-caseInsensitive =
-  Native.Regex.caseInsensitive
-
-
-{-| Check to see if a Regex is contained in a string.
-
-    contains (regex "123") "12345" == True
-    contains (regex "b+") "aabbcc" == True
-
-    contains (regex "789") "12345" == False
-    contains (regex "z+") "aabbcc" == False
--}
-contains : Regex -> String -> Bool
-contains =
-  Native.Regex.contains
-
-
-{-| A `Match` represents all of the details about a particular match in a string.
-Here are details on each field:
-
-  * `match` — the full string of the match.
-  * `submatches` — a regex might have [subpatterns, surrounded by
-    parentheses](https://developer.mozilla.org/en/docs/Web/JavaScript/Guide/Regular_Expressions#Using_Parenthesized_Substring_Matches).
-    If there are N subpatterns, there will be N elements in the `submatches` list.
-    Each submatch in this list is a `Maybe` because not all subpatterns may trigger.
-    For example, `(regex "(a+)|(b+)")` will either match many `a`’s or
-    many `b`’s, but never both.
-  * `index` — the index of the match in the original string.
-  * `number` — if you find many matches, you can think of each one
-    as being labeled with a `number` starting at one. So the first time you
-    find a match, that is match `number` one. Second time is match `number` two.
-    This is useful when paired with `replace All` if replacement is dependent on how
-    many times a pattern has appeared before.
--}
-type alias Match =
-    { match : String
-    , submatches : List (Maybe String)
-    , index : Int
-    , number : Int
-    }
-
-
-{-| `HowMany` is used to specify how many matches you want to make. So
-`replace All` would replace every match, but `replace (AtMost 2)` would
-replace at most two matches (i.e. zero, one, two, but never three or more).
--}
-type HowMany = All | AtMost Int
-
-
-{-| Find matches in a string:
-
-    findTwoCommas = find (AtMost 2) (regex ",")
-
-      -- map .index (findTwoCommas "a,b,c,d,e") == [1,3]
-      -- map .index (findTwoCommas "a b c d e") == []
-
-    places = find All (regex "[oi]n a (\\w+)") "I am on a boat in a lake."
-
-      -- map .match places == ["on a boat", "in a lake"]
-      -- map .submatches places == [ [Just "boat"], [Just "lake"] ]
--}
-find : HowMany -> Regex -> String -> List Match
-find =
-  Native.Regex.find
-
-
-{-| Replace matches. The function from `Match` to `String` lets
-you use the details of a specific match when making replacements.
-
-    devowel = replace All (regex "[aeiou]") (\_ -> "")
-
-      -- devowel "The quick brown fox" == "Th qck brwn fx"
-
-    reverseWords = replace All (regex "\\w+") (\{match} -> String.reverse match)
-
-      -- reverseWords "deliver mined parts" == "reviled denim strap"
--}
-replace : HowMany -> Regex -> (Match -> String) -> String -> String
-replace =
-  Native.Regex.replace
-
-
-{-| Split a string, using the regex as the separator.
-
-    split (AtMost 1) (regex ",") "tom,99,90,85" == ["tom","99,90,85"]
-
-    split All (regex ",") "a,b,c,d" == ["a","b","c","d"]
--}
-split : HowMany -> Regex -> String -> List String
-split =
-  Native.Regex.split

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

@@ -1,210 +0,0 @@
-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

@@ -1,168 +0,0 @@
-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)