Rewrite core

.github/workflows/set-issue-expectations.yml

@@ -0,0 +1,21 @@
+name: Set Issue Expectations
+on:
+  issues:
+    types: [opened]
+jobs:
+  comment-on-issue:
+    name: Comment On Issue
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/github@v1.0.0
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          args: |
+            comment "Thanks for reporting this! To set expectations:
+
+            - Issues are reviewed in [batches](https://github.com/elm/expectations/blob/master/batching.md), so it can take some time to get a response.
+            - Ask questions a [community forum](https://elm-lang.org/community). You will get an answer quicker that way!
+            - If you experience something similar, open a new issue. [We like duplicates](https://github.com/elm/expectations/blob/master/duplicates.md).
+
+            Finally, please be patient with the core team. They are trying their best with limited resources."

.github/workflows/set-pull-expectations.yml

@@ -0,0 +1,21 @@
+name: Set Pull Expectations
+on:
+  pull_request:
+    types: [opened]
+jobs:
+  comment-on-pull:
+    name: Comment On Pull
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/github@v1.0.0
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          args: |
+            comment "Thanks for suggesting these code changes. To set expectations:
+
+            - Pull requests are reviewed in [batches](https://github.com/elm/expectations/blob/master/batching.md), so it can take some time to get a response.
+            - Smaller pull requests are easier to review. To fix nine typos, nine specific issues will always go faster than one big one. Learn why [here](https://github.com/elm/expectations/blob/master/small-pull-requests.md).
+            - Reviewers may not know as much as you about certain situations, so add links to supporting evidence for important claims, especially regarding standards for CSS, HTTP, URI, etc.
+
+            Finally, please be patient with the core team. They are trying their best with limited resources."

NEWS

@@ -0,0 +1,51 @@
+# NEWS
+
+A little inline blog documenting the development of this library.
+
+# 2020/4/26 -- Merge elm/random back into core
+
+In my book, things that can manage effects belong in elm/core. This merge
+required replacing effect manager code with an alternative (in this case
+channel based) implementation.
+
+The new implementation is not that nice. Maybe it will look better when I
+manage to unifiy the two Task types. I think this is a case where the effect
+manager abstraction really worked well. I might just have my rose tinted
+specticles on.
+
+# 2020/4/26 -- A new internal module `Platform.Raw.Impure`
+
+This module contains an abstaction for functions that **do things** when
+they are run. The functions in this module are constrained to take one argument
+and return the unit tuple.
+
+Why can we not use Task's for this, given that this is _exactly_ what they are
+intended for. Well, two reasons
+
+1. Sometimes we need a guarantee that the function will be run exactly when we
+   need to run. Task are always enqueued; they are only run after stepping
+   through all the previous Tasks in the queue. Sometimes, this is not
+   acceptable, for instance when updating the listeners for a subscription
+   effect.
+
+2. We need to use impure functions to run Tasks. The
+   `Platform.Raw.Scheduler.enqueue` function takes a Task, adds it to the
+   scheduler queue and, if the scheduler is not currently stepping tasks (i.e.
+   this is not a reentrant call to `Platform.Raw.Scheduler.enqueue`), starts
+   stepping. This function is impure. However, if we represented it as a Task
+   we would have an infinite loop!
+
+Hopefully, use of this module can be reduced to a couple of key places and
+maybe even inlined into the scheduler is that is the only place that uses it.
+Hopefully, it will help us move all effectful functions out of elm.
+
+
+## 2020/04/26 - the future?
+
+I wan't to move to away from callbacks and towards async/await and promises (or
+futures). Firstly, I find that async/await is much easier to reason about than
+callbacks and leads to much prettier code. Also, in the back of my mind is the
+desire to eventually port the core libraries to rust for native compiled elm
+code.
+
+Todays change is just cosmetic, but hopefully is step 1.

README.md

@@ -1,30 +1,14 @@
-# Core Libraries
+# Elm-in-elm core libraries
 
-Every Elm project needs this package!
+> This repository currently contains a work in progress attempt to rewrite the elm core libraries into a form better suited for elm-in-elm.
+> It has not yet been upstreamed or adopted by elm-in-elm; I hope one day to integrate this into elm-in-elm but currently is just my work.
 
-It provides **basic functionality** like addition and subtraction as well as **data structures** like lists, dictionaries, and sets.
+## Aims
 
-> **New to Elm?** Go to [elm-lang.org](https://elm-lang.org) for an overview.
+* Minimal amount of Kernel code.
+* Easy to read.
 
+## Rules
 
-## Default Imports
-
-The modules in this package are so common, that some of them are imported by default in all Elm files. So it is as if every Elm file starts with these imports:
-
-```elm
-import Basics exposing (..)
-import List exposing (List, (::))
-import Maybe exposing (Maybe(..))
-import Result exposing (Result(..))
-import String exposing (String)
-import Char exposing (Char)
-import Tuple
-
-import Debug
-
-import Platform exposing ( Program )
-import Platform.Cmd as Cmd exposing ( Cmd )
-import Platform.Sub as 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 relatively 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.
+* Each kernel function may only be called via a type annotated redefinition in an elm file.
+* Kernel functions may **not** call other kernel functions.

benchmark/.gitignore

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

benchmark/elm.json

@@ -0,0 +1,29 @@
+{
+    "type": "application",
+    "source-directories": [
+        "src"
+    ],
+    "elm-version": "0.19.1",
+    "dependencies": {
+        "direct": {
+            "elm/browser": "1.0.1",
+            "elm/core": "1.0.2",
+            "elm/html": "1.0.0",
+            "elm-explorations/benchmark": "1.0.1"
+        },
+        "indirect": {
+            "BrianHicks/elm-trend": "2.1.3",
+            "Skinney/murmur3": "2.0.8",
+            "elm/json": "1.1.3",
+            "elm/regex": "1.0.0",
+            "elm/time": "1.0.0",
+            "elm/url": "1.0.0",
+            "elm/virtual-dom": "1.0.2",
+            "mdgriffith/style-elements": "5.0.1"
+        }
+    },
+    "test-dependencies": {
+        "direct": {},
+        "indirect": {}
+    }
+}

benchmark/src/Main.elm

@@ -0,0 +1,104 @@
+
+module Main exposing (..)
+
+import Benchmark.Runner exposing (BenchmarkProgram, program)
+
+import Array
+import Benchmark exposing (..)
+import List exposing (reverse)
+
+
+main : BenchmarkProgram
+main =
+    program suite
+
+cons : a -> List a -> List a
+cons =
+    (::)
+
+
+map2 : (a -> b -> result) -> List a -> List b -> List result
+map2 f xs1 xs2 =
+  map5 (\a b _ _ _ -> f a b) xs1 xs2 xs1 xs1 xs1
+
+
+{-|-}
+map3 : (a -> b -> c -> result) -> List a -> List b -> List c -> List result
+map3 f xs1 xs2 xs3 =
+  map5 (\a b c _ _ -> f a b c) xs1 xs2 xs3 xs1 xs1
+
+
+{-|-}
+map4 : (a -> b -> c -> d -> result) -> List a -> List b -> List c -> List d -> List result
+map4 f xs1 xs2 xs3 xs4 =
+  map5 (\a b c d _ -> f a b c d) xs1 xs2 xs3 xs4 xs1
+
+
+
+{-|-}
+map5 : (a -> b -> c -> d -> e -> result) -> List a -> List b -> List c -> List d -> List e -> List result
+map5 =
+    List.map5
+
+map2Help :  (a -> b -> result) -> List a -> List b -> List result -> List result
+map2Help f xs1 xs2 ys =
+  case (xs1, xs2) of
+    (head1 :: rest1, head2 :: rest2) ->
+      map2Help f rest1 rest2 (cons (f head1 head2) ys)
+    _ ->
+      ys
+
+map3Help : (a -> b -> c -> result) -> List a -> List b -> List c-> List result -> List result
+map3Help f xs1 xs2 xs3 ys =
+  case (xs1, xs2, xs3) of
+    (head1 :: rest1, head2 :: rest2, head3 :: rest3) ->
+      map3Help f rest1 rest2 rest3 (cons (f head1 head2 head3) ys)
+    _ ->
+      ys
+
+map4Help : (a -> b -> c -> d -> result) -> List a -> List b -> List c -> List d -> List result -> List result
+map4Help f xs1 xs2 xs3 xs4 ys =
+  case (xs1, xs2, (xs3, xs4)) of
+    (head1 :: rest1, head2 :: rest2, (head3 :: rest3, head4 :: rest4)) ->
+      map4Help f rest1 rest2 rest3 rest4 (cons (f head1 head2 head3 head4) ys)
+    _ ->
+      ys
+
+
+map5Help : (a -> b -> c -> d -> e -> result) -> List a -> List b -> List c -> List d -> List e -> List result -> List result
+map5Help f xs1 xs2 xs3 xs4 xs5 ys =
+  case (xs1, xs2, (xs3, xs4, xs5)) of
+    (head1 :: rest1, head2 :: rest2, (head3 :: rest3, head4 :: rest4, head5 :: rest5)) ->
+      map5Help f rest1 rest2 rest3 rest4 rest5 (cons (f head1 head2 head3 head4 head5) ys)
+    _ ->
+      ys
+
+
+suite : Benchmark
+suite =
+    let
+        sampleList =
+            List.range 0 4999
+    in
+    describe "mapping"
+        [ Benchmark.compare "map2"
+            "no kernel"
+            (\_ -> map2 (\a b -> a + b) sampleList sampleList)
+            "core"
+            (\_ -> List.map2 (\a b -> a + b) sampleList sampleList)
+        , Benchmark.compare "map3"
+            "no kernel"
+            (\_ -> map3 (\a b c -> a + b + c) sampleList sampleList sampleList)
+            "core"
+            (\_ -> List.map3 (\a b c -> a + b + c) sampleList sampleList sampleList)
+        , Benchmark.compare "map4"
+            "no kernel"
+            (\_ -> map4 (\a b c d -> a + b + c + d) sampleList sampleList sampleList sampleList)
+            "core"
+            (\_ -> List.map4 (\a b c d -> a + b + c + d) sampleList sampleList sampleList sampleList)
+        , Benchmark.compare "map5"
+            "no kernel"
+            (\_ -> map5 (\a b c d e -> a + b + c + d + e) sampleList sampleList sampleList sampleList sampleList)
+            "core"
+            (\_ -> List.map5 (\a b c d e -> a + b + c + d + e) sampleList sampleList sampleList sampleList sampleList)
+        ]

custom-core.sh

@@ -0,0 +1,52 @@
+#! /usr/bin/env bash
+
+set -o errexit;
+set -o nounset;
+
+if [[ ! -v ELM_HOME ]]; then
+    printf "Please set ELM_HOME!\n"
+    exit 1
+fi
+
+printf "Sucess if ends with DONE: "
+
+ELM="${ELM:-elm}"
+ELM_VERSION="$($ELM --version)"
+
+cd $1
+
+CORE_VERSIONS_DIR="$ELM_HOME/$ELM_VERSION/packages/elm/core"
+
+if [[ -d "$CORE_VERSIONS_DIR" ]]; then
+
+    CORE_VERSION_COUNT=$(ls "$CORE_VERSIONS_DIR" | wc -l)
+    CORE_VERSION=$(ls "$CORE_VERSIONS_DIR")
+    CORE_PACKAGE_DIR="$CORE_VERSIONS_DIR/$CORE_VERSION"
+
+    if [ $CORE_VERSION_COUNT == 1 ] && \
+        [[ -f $CORE_PACKAGE_DIR/custom ]] && \
+        [[ -d "$ELM_HOME/$ELM_VERSION/packages/elm/time" ]] && \
+        [[ -d "$ELM_HOME/$ELM_VERSION/packages/elm/random" ]] ; then
+        printf "REFRESH "
+    else
+        printf "INIT "
+        ./init-elm-home.sh > /dev/null
+    fi
+else
+    printf "INIT "
+    ./init-elm-home.sh > /dev/null
+fi
+
+CORE_VERSION=$(ls $CORE_VERSIONS_DIR)
+CORE_PACKAGE_DIR="$CORE_VERSIONS_DIR/$CORE_VERSION"
+
+./stub.py "$ELM_HOME/$ELM_VERSION/packages/elm/time"
+./stub.py "$ELM_HOME/$ELM_VERSION/packages/elm/random"
+
+rm -rf "$CORE_PACKAGE_DIR" > /dev/null
+mkdir "$CORE_PACKAGE_DIR"
+cp -r src "$CORE_PACKAGE_DIR"/ > /dev/null
+cp -r elm.json "$CORE_PACKAGE_DIR"/ > /dev/null
+touch "$CORE_PACKAGE_DIR/custom"
+
+printf "DONE\n"

design-documents/OperatorExample.elm

@@ -0,0 +1,33 @@
+module OperatorExample exposing (..)
+
+import Platform
+
+
+compositionExample : (Float -> Float -> Float)
+compositionExample x =
+    mean 6
+        >> mean x
+
+
+mean : Float -> Float -> Float
+mean a b =
+    (a + b) / 2
+
+
+ident : Bool -> Bool
+ident b =
+    not (not b)
+
+
+main =
+    let
+        m = compositionExample 21 4
+
+        _ = ident True
+    in
+
+    Platform.worker
+        { init = \() -> (m, Cmd.none)
+        , update = \model _ -> (model, Cmd.none)
+        , subscriptions = \_ -> Sub.none
+        }

design-documents/elm-minimal-master/.gitignore

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

design-documents/elm-minimal-master/elm.json

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