elm-rails 0.1.2 → 0.2.0

data/test/rails5.0/elm-stuff/build-artifacts/0.18.0/elm-lang/virtual-dom/2.0.3/VirtualDom-Report.elmo

@@ -0,0 +1,98 @@
+var _elm_lang$virtual_dom$VirtualDom_Report$some = function (list) {
+	return !_elm_lang$core$List$isEmpty(list);
+};
+var _elm_lang$virtual_dom$VirtualDom_Report$TagChanges = F4(
+	function (a, b, c, d) {
+		return {removed: a, changed: b, added: c, argsMatch: d};
+	});
+var _elm_lang$virtual_dom$VirtualDom_Report$emptyTagChanges = function (argsMatch) {
+	return A4(
+		_elm_lang$virtual_dom$VirtualDom_Report$TagChanges,
+		{ctor: '[]'},
+		{ctor: '[]'},
+		{ctor: '[]'},
+		argsMatch);
+};
+var _elm_lang$virtual_dom$VirtualDom_Report$hasTagChanges = function (tagChanges) {
+	return _elm_lang$core$Native_Utils.eq(
+		tagChanges,
+		A4(
+			_elm_lang$virtual_dom$VirtualDom_Report$TagChanges,
+			{ctor: '[]'},
+			{ctor: '[]'},
+			{ctor: '[]'},
+			true));
+};
+var _elm_lang$virtual_dom$VirtualDom_Report$SomethingChanged = function (a) {
+	return {ctor: 'SomethingChanged', _0: a};
+};
+var _elm_lang$virtual_dom$VirtualDom_Report$MessageChanged = F2(
+	function (a, b) {
+		return {ctor: 'MessageChanged', _0: a, _1: b};
+	});
+var _elm_lang$virtual_dom$VirtualDom_Report$VersionChanged = F2(
+	function (a, b) {
+		return {ctor: 'VersionChanged', _0: a, _1: b};
+	});
+var _elm_lang$virtual_dom$VirtualDom_Report$CorruptHistory = {ctor: 'CorruptHistory'};
+var _elm_lang$virtual_dom$VirtualDom_Report$UnionChange = F2(
+	function (a, b) {
+		return {ctor: 'UnionChange', _0: a, _1: b};
+	});
+var _elm_lang$virtual_dom$VirtualDom_Report$AliasChange = function (a) {
+	return {ctor: 'AliasChange', _0: a};
+};
+var _elm_lang$virtual_dom$VirtualDom_Report$Fine = {ctor: 'Fine'};
+var _elm_lang$virtual_dom$VirtualDom_Report$Risky = {ctor: 'Risky'};
+var _elm_lang$virtual_dom$VirtualDom_Report$Impossible = {ctor: 'Impossible'};
+var _elm_lang$virtual_dom$VirtualDom_Report$worstCase = F2(
+	function (status, statusList) {
+		worstCase:
+		while (true) {
+			var _p0 = statusList;
+			if (_p0.ctor === '[]') {
+				return status;
+			} else {
+				switch (_p0._0.ctor) {
+					case 'Impossible':
+						return _elm_lang$virtual_dom$VirtualDom_Report$Impossible;
+					case 'Risky':
+						var _v1 = _elm_lang$virtual_dom$VirtualDom_Report$Risky,
+							_v2 = _p0._1;
+						status = _v1;
+						statusList = _v2;
+						continue worstCase;
+					default:
+						var _v3 = status,
+							_v4 = _p0._1;
+						status = _v3;
+						statusList = _v4;
+						continue worstCase;
+				}
+			}
+		}
+	});
+var _elm_lang$virtual_dom$VirtualDom_Report$evaluateChange = function (change) {
+	var _p1 = change;
+	if (_p1.ctor === 'AliasChange') {
+		return _elm_lang$virtual_dom$VirtualDom_Report$Impossible;
+	} else {
+		return ((!_p1._1.argsMatch) || (_elm_lang$virtual_dom$VirtualDom_Report$some(_p1._1.changed) || _elm_lang$virtual_dom$VirtualDom_Report$some(_p1._1.removed))) ? _elm_lang$virtual_dom$VirtualDom_Report$Impossible : (_elm_lang$virtual_dom$VirtualDom_Report$some(_p1._1.added) ? _elm_lang$virtual_dom$VirtualDom_Report$Risky : _elm_lang$virtual_dom$VirtualDom_Report$Fine);
+	}
+};
+var _elm_lang$virtual_dom$VirtualDom_Report$evaluate = function (report) {
+	var _p2 = report;
+	switch (_p2.ctor) {
+		case 'CorruptHistory':
+			return _elm_lang$virtual_dom$VirtualDom_Report$Impossible;
+		case 'VersionChanged':
+			return _elm_lang$virtual_dom$VirtualDom_Report$Impossible;
+		case 'MessageChanged':
+			return _elm_lang$virtual_dom$VirtualDom_Report$Impossible;
+		default:
+			return A2(
+				_elm_lang$virtual_dom$VirtualDom_Report$worstCase,
+				_elm_lang$virtual_dom$VirtualDom_Report$Fine,
+				A2(_elm_lang$core$List$map, _elm_lang$virtual_dom$VirtualDom_Report$evaluateChange, _p2._0));
+	}
+};

data/test/rails5.0/elm-stuff/build-artifacts/0.18.0/elm-lang/virtual-dom/2.0.3/VirtualDom.elmo

@@ -0,0 +1,30 @@
+var _elm_lang$virtual_dom$VirtualDom$programWithFlags = function (impl) {
+	return A2(_elm_lang$virtual_dom$Native_VirtualDom.programWithFlags, _elm_lang$virtual_dom$VirtualDom_Debug$wrapWithFlags, impl);
+};
+var _elm_lang$virtual_dom$VirtualDom$program = function (impl) {
+	return A2(_elm_lang$virtual_dom$Native_VirtualDom.program, _elm_lang$virtual_dom$VirtualDom_Debug$wrap, impl);
+};
+var _elm_lang$virtual_dom$VirtualDom$keyedNode = _elm_lang$virtual_dom$Native_VirtualDom.keyedNode;
+var _elm_lang$virtual_dom$VirtualDom$lazy3 = _elm_lang$virtual_dom$Native_VirtualDom.lazy3;
+var _elm_lang$virtual_dom$VirtualDom$lazy2 = _elm_lang$virtual_dom$Native_VirtualDom.lazy2;
+var _elm_lang$virtual_dom$VirtualDom$lazy = _elm_lang$virtual_dom$Native_VirtualDom.lazy;
+var _elm_lang$virtual_dom$VirtualDom$defaultOptions = {stopPropagation: false, preventDefault: false};
+var _elm_lang$virtual_dom$VirtualDom$onWithOptions = _elm_lang$virtual_dom$Native_VirtualDom.on;
+var _elm_lang$virtual_dom$VirtualDom$on = F2(
+	function (eventName, decoder) {
+		return A3(_elm_lang$virtual_dom$VirtualDom$onWithOptions, eventName, _elm_lang$virtual_dom$VirtualDom$defaultOptions, decoder);
+	});
+var _elm_lang$virtual_dom$VirtualDom$style = _elm_lang$virtual_dom$Native_VirtualDom.style;
+var _elm_lang$virtual_dom$VirtualDom$mapProperty = _elm_lang$virtual_dom$Native_VirtualDom.mapProperty;
+var _elm_lang$virtual_dom$VirtualDom$attributeNS = _elm_lang$virtual_dom$Native_VirtualDom.attributeNS;
+var _elm_lang$virtual_dom$VirtualDom$attribute = _elm_lang$virtual_dom$Native_VirtualDom.attribute;
+var _elm_lang$virtual_dom$VirtualDom$property = _elm_lang$virtual_dom$Native_VirtualDom.property;
+var _elm_lang$virtual_dom$VirtualDom$map = _elm_lang$virtual_dom$Native_VirtualDom.map;
+var _elm_lang$virtual_dom$VirtualDom$text = _elm_lang$virtual_dom$Native_VirtualDom.text;
+var _elm_lang$virtual_dom$VirtualDom$node = _elm_lang$virtual_dom$Native_VirtualDom.node;
+var _elm_lang$virtual_dom$VirtualDom$Options = F2(
+	function (a, b) {
+		return {stopPropagation: a, preventDefault: b};
+	});
+var _elm_lang$virtual_dom$VirtualDom$Node = {ctor: 'Node'};
+var _elm_lang$virtual_dom$VirtualDom$Property = {ctor: 'Property'};

data/test/rails5.0/elm-stuff/exact-dependencies.json

@@ -0,0 +1,5 @@
+{
+    "elm-lang/virtual-dom": "2.0.3",
+    "elm-lang/html": "2.0.0",
+    "elm-lang/core": "5.0.0"
+}

data/test/rails5.0/elm-stuff/packages/elm-lang/core/5.0.0/CONTRIBUTING.md

@@ -0,0 +1,41 @@
+# Contributing to the core libraries
+
+Thanks helping with the development of Elm! This document describes the basic
+standards for opening pull requests and making the review process as smooth as
+possible.
+
+## Ground rules
+
+  * Always make pull requests minimal. If it can be split up, it should be split up.
+  * Use style consistent with the file you are modifying.
+  * Use descriptive titles for PRs
+  * Provide all the necessary context for evaluation in the PR.
+    If there are relevant issues or examples or discussions, add them.
+    If things can be summarized, summarize them. The easiest PRs are ones
+    that already address the reviewers questions and concerns.
+
+## Documentation Fixes
+
+If you want to fix docs, just open a PR. This is super helpful!
+
+## Bug Fixes
+
+If you find an issue or see one you want to work on, go for it!
+
+The best strategy is often to dive in. Asking for directions usually
+does not work. If someone knew the specifics and knew how how to fix
+it, it is likely they would have already sent the PR themselves!
+
+Also, be sure you are testing.
+
+## Adding New Functions
+
+We are fairly conservative about adding new functions to core libraries.
+If you want to augment the `List` or `Array` library, we recommend creating
+small packages called `list-extras` or `array-extras` that have all the
+features you want.
+
+Long term, we will set up a process to review `*-extras` packages to move
+stuff into core. By going through packages, it will be much easier to assess
+whether a function is pleasant and useful in practice before committing to it
+in the core libraries.

data/test/rails5.0/elm-stuff/packages/elm-lang/core/5.0.0/LICENSE

@@ -0,0 +1,30 @@
+Copyright (c) 2014-present, Evan Czaplicki
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+
+    * Redistributions in binary form must reproduce the above
+      copyright notice, this list of conditions and the following
+      disclaimer in the documentation and/or other materials provided
+      with the distribution.
+
+    * Neither the name of Evan Czaplicki nor the names of other
+      contributors may be used to endorse or promote products derived
+      from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/test/rails5.0/elm-stuff/packages/elm-lang/core/5.0.0/README.md

@@ -0,0 +1,34 @@
+# Elm Core Libraries
+
+[![Build Status](https://travis-ci.org/elm-lang/core.svg?branch=master)](https://travis-ci.org/elm-lang/core)
+
+Every Elm project needs the core libraries. They provide basic functionality including:
+
+  * The Basics — addition, subtraction, etc.
+  * Data Structures — lists, dictionaries, sets, etc.
+
+
+## Default Imports
+
+All Elm files have some default imports:
+
+```elm
+import Basics exposing (..)
+import List exposing ( List, (::) )
+import Maybe exposing ( Maybe( Just, Nothing ) )
+import Result exposing ( Result( Ok, Err ) )
+import String
+import Tuple
+
+import Debug
+
+import Platform exposing ( Program )
+import Platform.Cmd exposing ( Cmd, (!) )
+import Platform.Sub exposing ( Sub )
+```
+
+The intention is to include things that are both extremely useful and very
+unlikely to overlap with anything that anyone will ever write in a library.
+By keeping the set of default imports small, it also becomes easier to use
+whatever version of `map` suits your fancy. Finally, it makes it easier to
+figure out where the heck a function is coming from.

data/test/rails5.0/elm-stuff/packages/elm-lang/core/5.0.0/changelog.md

@@ -0,0 +1,143 @@
+# 0.15
+
+### Syntax
+
+New `import` syntax with keyword `exposing`.
+
+### Module Changes
+
+  * Move `Http` to `elm-http` package and totally redo API
+  * Remove `WebSocket` module
+  * Add `Task` module
+
+### Channels become Mailboxes
+
+`Graphics.Input` now works with this API (from module `Signal`):
+
+```elm
+type alias Mailbox a = { address : Address a, signal : Signal a }
+
+mailbox : a -> Mailbox a
+```
+
+You can then send messages to the `Address` with functions like `Signal.send`
+and `Signal.message`, or create forwarding addresses with `Signal.forwardTo`.
+
+### Text in Collages
+
+`Graphics.Collage` now has two new functions:
+
+```elm
+text : Text -> Form
+outlinedText : LineStyle -> Text -> Form
+```
+
+These functions render text with the canvas, making things quite a bit faster.
+The underlying implementation of `Text` has also been improved dramatically.
+
+### Miscellaneous
+
+  * Change types of `head`, `tail`, `maximum`, `minimum` by wrapping output in `Maybe`
+  * Move `leftAligned`, `centered`, `rightAligned` from `Text` to `Graphics.Element`
+  * Move `asText` from `Text` to `Graphics.Element`, renaming it to `show` in the process
+  * Remove `Text.plainText` (can be replaced by `Graphics.Element.leftAligned << Text.fromString`)
+  * Change type of `Keyboard.keysDown` from `Signal (List KeyCode)` to `Signal (Set KeyCode)`
+  * Remove `Keyboard.directions`
+  * Rename `Keyboard.lastPressed` to `Keyboard.presses`
+
+
+# 0.14
+
+### Syntax
+
+  * Keyword `type` becomes `type alias`
+  * Keyword `data` becomes `type`
+  * Remove special list syntax in types, so `[a]` becomes `List a`
+
+
+### Reduce Default Imports
+
+The set of default imports has been reduced to the following:
+
+```haskell
+import Basics (..)
+import Maybe ( Maybe( Just, Nothing ) )
+import Result ( Result( Ok, Err ) )
+import List ( List )
+import Signal ( Signal )
+```
+
+### Make JSON parsing easy
+
+  * Added `Json.Decode` and `Json.Encode` libraries
+
+
+### Use more natural names
+
+  * Rename `String.show` to `String.toString`
+
+  * Replace `List.zip` with `List.map2 (,)`
+  * Replace `List.zipWith f` with `List.map2 f`
+
+  * Rename `Signal.liftN` to `Signal.mapN`
+  * Rename `Signal.merges` to `Signal.mergeMany`
+
+
+### Simplify Signal Library
+
+  * Revamp `Input` concept as `Signal.Channel`
+  * Remove `Signal.count`
+  * Remove `Signal.countIf`
+  * Remove `Signal.combine`
+
+
+### Randomness Done Right
+
+  * No longer signal-based
+  * Use a `Generator` to create random values
+
+
+
+### Revamp Maybes and Error Handling
+
+  * Add the following functions to `Maybe`
+
+        withDefault : a -> Maybe a -> a
+        oneOf : List (Maybe a) -> Maybe a
+        map : (a -> b) -> Maybe a -> Maybe b
+        andThen : Maybe a -> (a -> Maybe b) -> Maybe b
+
+  * Remove `Maybe.maybe` so `maybe 0 sqrt Nothing` becomes `withDefault 0 (map sqrt Nothing)`
+
+  * Remove `Maybe.isJust` and `Maybe.isNothing` in favor of pattern matching
+
+  * Add `Result` library for proper error handling. This is for cases when
+    you want a computation to succeed, but if there is a mistake, it should
+    produce a nice error message.
+
+  * Remove `Either` in favor of `Result` or custom union types
+
+  * Revamp functions that result in a `Maybe`.
+
+      - Remove `Dict.getOrElse` and `Dict.getOrFail` in favor of `withDefault 0 (Dict.get key dict)`
+      - Remove `Array.getOrElse` and `Array.getOrFail` in favor of `withDefault 0 (Array.get index array)`
+      - Change `String.toInt : String -> Maybe Int` to `String.toInt : String -> Result String Int`
+      - Change `String.toFloat : String -> Maybe Float` to `String.toFloat : String -> Result String Float`
+
+
+### Make appending more logical
+
+  * Add the following functions to `Text`:
+      
+        empty : Text
+        append : Text -> Text -> Text
+        concat : [Text] -> Text
+        join : Text -> [Text] -> Text
+
+  * Make the following changes in `List`:
+      - Replace `(++)` with `append`
+      - Remove `join`
+
+### Miscellaneous
+
+  * Rename `Text.toText` to `Text.fromString`

data/test/rails5.0/elm-stuff/packages/elm-lang/core/5.0.0/elm-package.json

@@ -0,0 +1,38 @@
+{
+    "version": "5.0.0",
+    "summary": "Elm's standard libraries",
+    "repository": "http://github.com/elm-lang/core.git",
+    "license": "BSD3",
+    "source-directories": [
+        "src"
+    ],
+    "exposed-modules": [
+        "Array",
+        "Basics",
+        "Bitwise",
+        "Char",
+        "Color",
+        "Date",
+        "Debug",
+        "Dict",
+        "Json.Decode",
+        "Json.Encode",
+        "List",
+        "Maybe",
+        "Platform",
+        "Platform.Cmd",
+        "Platform.Sub",
+        "Process",
+        "Random",
+        "Regex",
+        "Result",
+        "Set",
+        "String",
+        "Task",
+        "Time",
+        "Tuple"
+    ],
+    "native-modules": true,
+    "dependencies": {},
+    "elm-version": "0.18.0 <= v < 0.19.0"
+}

data/test/rails5.0/elm-stuff/packages/elm-lang/core/5.0.0/src/Array.elm

@@ -0,0 +1,240 @@
+module Array exposing
+  ( Array
+  , empty, repeat, initialize, fromList
+  , isEmpty, length, push, append
+  , get, set
+  , slice, toList, toIndexedList
+  , map, indexedMap, filter, foldl, foldr
+  )
+
+{-| A library for fast immutable arrays. The elements in an array must have the
+same type. The arrays are implemented in Relaxed Radix Balanced-Trees for fast
+reads, updates, and appends.
+
+# Arrays
+@docs Array
+
+# Creating Arrays
+@docs empty, repeat, initialize, fromList
+
+# Basics
+@docs isEmpty, length, push, append
+
+# Get and Set
+@docs get, set
+
+# Taking Arrays Apart
+@docs slice, toList, toIndexedList
+
+# Mapping, Filtering, and Folding
+@docs map, indexedMap, filter, foldl, foldr
+-}
+
+import Native.Array
+import Basics exposing (..)
+import Maybe exposing (..)
+import List
+
+
+{-| Representation of fast immutable arrays. You can create arrays of integers
+(`Array Int`) or strings (`Array String`) or any other type of value you can
+dream up.
+-}
+type Array a = Array
+
+
+{-| Initialize an array. `initialize n f` creates an array of length `n` with
+the element at index `i` initialized to the result of `(f i)`.
+
+    initialize 4 identity    == fromList [0,1,2,3]
+    initialize 4 (\n -> n*n) == fromList [0,1,4,9]
+    initialize 4 (always 0)  == fromList [0,0,0,0]
+-}
+initialize : Int -> (Int -> a) -> Array a
+initialize =
+  Native.Array.initialize
+
+
+{-| Creates an array with a given length, filled with a default element.
+
+    repeat 5 0     == fromList [0,0,0,0,0]
+    repeat 3 "cat" == fromList ["cat","cat","cat"]
+
+Notice that `repeat 3 x` is the same as `initialize 3 (always x)`.
+-}
+repeat : Int -> a -> Array a
+repeat n e =
+  initialize n (always e)
+
+
+{-| Create an array from a list.
+-}
+fromList : List a -> Array a
+fromList =
+  Native.Array.fromList
+
+
+{-| Create a list of elements from an array.
+
+    toList (fromList [3,5,8]) == [3,5,8]
+-}
+toList : Array a -> List a
+toList =
+  Native.Array.toList
+
+
+-- TODO: make this a native function.
+{-| Create an indexed list from an array. Each element of the array will be
+paired with its index.
+
+    toIndexedList (fromList ["cat","dog"]) == [(0,"cat"), (1,"dog")]
+-}
+toIndexedList : Array a -> List (Int, a)
+toIndexedList array =
+  List.map2
+    (,)
+    (List.range 0 (Native.Array.length array - 1))
+    (Native.Array.toList array)
+
+
+{-| Apply a function on every element in an array.
+
+    map sqrt (fromList [1,4,9]) == fromList [1,2,3]
+-}
+map : (a -> b) -> Array a -> Array b
+map =
+  Native.Array.map
+
+
+{-| Apply a function on every element with its index as first argument.
+
+    indexedMap (*) (fromList [5,5,5]) == fromList [0,5,10]
+-}
+indexedMap : (Int -> a -> b) -> Array a -> Array b
+indexedMap =
+  Native.Array.indexedMap
+
+
+{-| Reduce an array from the left. Read `foldl` as “fold from the left”.
+
+    foldl (::) [] (fromList [1,2,3]) == [3,2,1]
+-}
+foldl : (a -> b -> b) -> b -> Array a -> b
+foldl =
+  Native.Array.foldl
+
+
+{-| Reduce an array from the right. Read `foldr` as “fold from the right”.
+
+    foldr (+) 0 (repeat 3 5) == 15
+-}
+foldr : (a -> b -> b) -> b -> Array a -> b
+foldr =
+  Native.Array.foldr
+
+
+{-| Keep only elements that satisfy the predicate:
+
+    filter isEven (fromList [1..6]) == (fromList [2,4,6])
+-}
+filter : (a -> Bool) -> Array a -> Array a
+filter isOkay arr =
+  let
+    update x xs =
+      if isOkay x then
+        Native.Array.push x xs
+      else
+        xs
+  in
+    Native.Array.foldl update Native.Array.empty arr
+
+{-| Return an empty array.
+
+    length empty == 0
+-}
+empty : Array a
+empty =
+  Native.Array.empty
+
+
+{-| Push an element to the end of an array.
+
+    push 3 (fromList [1,2]) == fromList [1,2,3]
+-}
+push : a -> Array a -> Array a
+push =
+  Native.Array.push
+
+
+{-| Return Just the element at the index or Nothing if the index is out of range.
+
+    get  0 (fromList [0,5,3]) == Just 0
+    get  2 (fromList [0,5,3]) == Just 3
+    get  5 (fromList [0,5,3]) == Nothing
+    get -1 (fromList [0,5,3]) == Nothing
+
+-}
+get : Int -> Array a -> Maybe a
+get i array =
+  if 0 <= i && i < Native.Array.length array then
+    Just (Native.Array.get i array)
+  else
+    Nothing
+
+
+{-| Set the element at a particular index. Returns an updated array.
+If the index is out of range, the array is unaltered.
+
+    set 1 7 (fromList [1,2,3]) == fromList [1,7,3]
+-}
+set : Int -> a -> Array a -> Array a
+set =
+  Native.Array.set
+
+
+{-| Get a sub-section of an array: `(slice start end array)`. The `start` is a
+zero-based index where we will start our slice. The `end` is a zero-based index
+that indicates the end of the slice. The slice extracts up to but not including
+`end`.
+
+    slice  0  3 (fromList [0,1,2,3,4]) == fromList [0,1,2]
+    slice  1  4 (fromList [0,1,2,3,4]) == fromList [1,2,3]
+
+Both the `start` and `end` indexes can be negative, indicating an offset from
+the end of the array.
+
+    slice  1 -1 (fromList [0,1,2,3,4]) == fromList [1,2,3]
+    slice -2  5 (fromList [0,1,2,3,4]) == fromList [3,4]
+
+This makes it pretty easy to `pop` the last element off of an array: `slice 0 -1 array`
+-}
+slice : Int -> Int -> Array a -> Array a
+slice =
+  Native.Array.slice
+
+
+{-| Return the length of an array.
+
+    length (fromList [1,2,3]) == 3
+-}
+length : Array a -> Int
+length =
+  Native.Array.length
+
+
+{-| Determine if an array is empty.
+
+    isEmpty empty == True
+-}
+isEmpty : Array a -> Bool
+isEmpty array =
+    length array == 0
+
+
+{-| Append two arrays to a new one.
+
+    append (repeat 2 42) (repeat 3 81) == fromList [42,42,81,81,81]
+-}
+append : Array a -> Array a -> Array a
+append =
+  Native.Array.append