view : Model -> Html Msg
view model =
    div [] [ text "Hello, world!" ]


type alias Model =
    {}


model : Model
model =
    {}


type Msg
    = NoOp


update : Msg -> Model -> Model
update msg model =
    case msg of
        NoOp ->
            model

// Relying on side-effects:
var counter = 0;
function incrementCounter () {
    counter++
}


// Limiting side-effects:
function incrementCounter (counter) {
    return ++counter
}

// incrementCounter : number -> number
function incrementCounter (counter) {
    return ++counter
}

// incrementCounter : number -> number
function incrementCounter (counter) {
    if (typeof counter === 'number') {
        return ++counter
    } else {
        throw "type error: called incrementCounter with non-number argument."
    }
}

// Polyfill for IE and Opera Mobile from MDN Number.isInteger entry(https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isInteger)
Number.isInteger = Number.isInteger || function(value) {
  return typeof value === 'number' &&
    isFinite(value) &&
    Math.floor(value) === value;
};

function incrementCounter (counter) {
    if (Number.isInteger(counter)) {
        return ++counter
    } else {
        throw "type error: called incrementCounter with non-integer argument."
    }
}

incrementCounter : Int -> Int
incrementCounter counter =
    counter + 1

// Polyfill for IE and Opera Mobile from MDN Number.isInteger entry (https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isInteger)
Number.isInteger = Number.isInteger || function(value) {
  return typeof value === 'number' &&
    isFinite(value) &&
    Math.floor(value) === value;
};

function incrementCounter (counter) {
    if (Number.isInteger(counter)) {
        return ++counter
    } else {
        throw "type error: called incrementCounter with non-integer argument."
    }
}

incrementCounter : Int -> Int
incrementCounter counter =
    counter + 1

The argument to function incrementCounter is causing a mismatch.
Function incrementCounter is expecting the argument to be:

Int

But it is:

Float

Hint: Elm does not automatically convert between Ints and Floats. 
Use toFloat and round to do specific conversions.

-- error: TYPE MISMATCH - /Users/tessakelly/Documents/elm-piano/src/Model.elm:18:1
The definition of `init` does not match its type annotation.
The type annotation for `init` says it always returns:
    Model
But the returned value (shown above) is a:
    { currentlyPlaying : AllDict.AllDict ( Octave, Note ) v Float
    , debounce : Maybe a
    , octave : number
    , played : List b
    , time : number1
    }
Hint: The record fields do not match up. Maybe you made one of these typos?
    
    debouncer <-> debounce

ourFloat : Float
ourFloat =
    1.000000


counter : Int
counter =
    round ourFloat


incrementedCounter : Int
incrementedCounter =
    incrementCounter counter

{- MORE SUCCINCTLY -}
incrementedCounter : Int
incrementedCounter =
    incrementCounter 
        (round 1.000000)

main =
    beginnerProgram
        { model = model 
            -- our application state and data
        , update = update  
            -- the way that the application 
            -- state and data can change
        , view = view -- the view!
        }

formatChickenCount : Int -> String
formatChickenCount count =
    if count == 1 then
        "There is 1 chicken."
    else
        "There are " ++ toString count ++ " chickens."

formatChickenCount : Int -> String
formatChickenCount count =
    if count == 1 then
        "There is 1 chicken."
    else
        "There are " ++ toString count ++ " chickens."

$ elm

Elm Platform 0.18.0 - a way to run all Elm tools

Usage: elm <command> [<args>]

Available commands include:

  make      Compile an Elm file or project into JS or HTML
  package   Manage packages from <http://package.elm-lang.org>
  reactor   Develop with compile-on-refresh and time-travel debugging
  repl      A REPL for running individual expressions

You can learn more about a specific command by running things like:

  elm make --help
  elm package --help
  elm <command> --help

In all these cases we are simply running 'elm-<command>' so if you create an
executable named 'elm-foobar' you will be able to run it as 'elm foobar' as
long as it appears on your PATH.

$ mkdir prairie-chicken-counter
$ cd prairie-chicken-counter
$ touch Main.elm

$ elm reactor

elm-reactor 0.18.0
Listening on http://localhost:8000

{-| Using (++) as an infix operator:
-}
exclaim : String -> String
exclaim comment =
    comment ++ "!"


{-| Using (++) as a prefix operator:
-}
noSeriouslyExclaimTho : String -> String
noSeriouslyExclaimTho comment =
    (++) comment "!!!!"


{- More complex operations with Strings can be explored 
in the String documentation:
http://package.elm-lang.org/packages/elm-lang/core/5.1.1/String
-}

{-| Example of a float.
-}
float : Float
float =
    99.99


{-| Example of an integer.
-}
integer : Int
integer =
    round float


{- Check out the Basics docs for more: 
http://package.elm-lang.org/packages/elm-lang/core/5.1.1/Basics
-}

anEmptyList : List a
anEmptyList =
    []


aListOfStrings : List String
aListOfStrings =
    [ "Just", "some", "strings!" ]


hasMyName : List String -> Bool
hasMyName nameList =
    List.member "Tessa" nameList


addAnElementToTheFrontOfTheList : List String
addAnElementToTheFrontOfTheList =
    "cons" :: [ "is the name of this operator" ]

{- Lists also have package documentation in the 
core section of the package website.

http://package.elm-lang.org/packages/elm-lang/core/5.1.1/List
-}

someRecord =
    { whatIsIt = "Named key value pairs"
    , doTheyAllNeedTheSameType = False
    , howDoesThisWorkInTheTypeSystem =
        "We'll look at type aliases on the next slide"
    , someValue = ( 1, 2, 3 )
    }


updatedRecord =
    { someRecord
        | whatIsIt =
            "An updated record--the old record isn't changed by this operation"
    }


getSomeValue : { a | someValue : b } -> b
getSomeValue argument =
    argument.someValue

getSomeValueTwo : { a | someValue : b } -> b
getSomeValueTwo argument =
    .someValue argument

getSomeValueThree : { a | someValue : b } -> b
getSomeValueThree { someValue } =
    someValue

{-| Type aliases are a convenience that will help the
compiler give you nice error messages.
-}
type alias RecordExample =
    { fieldName : String
    , aBoolField : Bool
    , somethingElse : List ( String, Bool ) -- This is a list of tuples.
    }


aRecord : RecordExample
aRecord =
    { fieldName = "field value"
    , aBoolField = False
    , somethingElse = [ ("Hello", True) ] 
    }


{-| Type aliases give you an order-based constructor. -}
anotherRecord : RecordExample
anotherRecord =
    RecordExample
        """ fieldName values are strings, so we need to pass in a string first.
            Use triple double-quotation marks for a multi-line string!
        """
        True
        []

iAmAFunction : String -> String
iAmAFunction argument =
    "This is the body of the function, plus the argument: " ++ argument


iAmAFunctionWithLocalScope : Int -> Int
iAmAFunctionWithLocalScope argument =
    let
        iAmALocalVariable : Int
        iAmALocalVariable =
            7

        localFunction localArgument =
            9 + localArgument
    in
        argument + localFunction 10


{-| `\item -> item ++ "!!!"` is an anonymous function.
-}
exclaimList : List String -> List String
exclaimList =
    -- Notice  that we haven't explicitly named the argument to this function
    List.map (\item -> item ++ "!!!")

{- `(|>)`, `(<|)`

These operators pass the result of an operation on. 
Pipes make it easier to do many data transformations in
a row and can serve as a replacement for parentheses.
-}


{-| This is "Hello!!!" -}
helloWithParens : String
helloWithParens =
    ((++) "Hello") "!!!"


{-| This is also "Hello!!!", but notice the `|>` instead of the parens -}
helloWithPipeOperator : String
helloWithPipeOperator =
    "!!!" |> (++) "Hello"

{- `(>>)`, `(<<)` -- compose functions.
-}


mathItUpWithoutFunctionComposition : List Int -> List Int
mathItUpWithoutFunctionComposition =
    List.map (\value -> value * 2 + 1)


{-| mathItUp [ 0, 1, 2  ] == [ 1, 3, 5 ]
-}
mathItUp : List Int -> List Int
mathItUp =
    List.map ((*) 2 >> (+) 1)

view : Model -> Html Msg
view model = div [class[ Container ]
        ] [Html.CssHelpers.style css,
 viewPiano model.currentlyPlaying model.octave, label [for "input" ] [text "Play input" ], input [autofocus True , onKeyDown (Update.Debounce << Update.HandleKeyDown) , onKeyUp (Update.withNote (\note -> Update.Stop ( model.octave, note ))), 
            id "input"][] , br[][] , h4[] [ text "Record:" ]
        , viewPlayedNotes model.played , h4[] [ text "Playing:" ]
        , viewPlayingNotes model.currentlyPlaying 
]
viewPiano : AllDict.AllDict ( Model.Octave, Model.Note ) a Float -> Model.Octave -> Html Msg
viewPiano currentlyPlaying selectedOctave =
 div [class[Piano]] (List.repeat 7 () |> List.indexedMap (\index _ -> viewOctave currentlyPlaying selectedOctave index))

view : Model -> Html Msg
view model =
    div
        [ class [ Container ]
        ]
        [ Html.CssHelpers.style css
        , viewPiano model.currentlyPlaying model.octave
        , label [ for "input" ] [ text "Play input" ]
        , input
            [ autofocus True
            , onKeyDown (Update.Debounce << Update.HandleKeyDown)
            , onKeyUp (Update.withNote (\note -> Update.Stop ( model.octave, note )))
            , id "input"
            ]
            []
        , br [] []
        , h4 [] [ text "Record:" ]
        , viewPlayedNotes model.played
        , h4 [] [ text "Playing:" ]
        , viewPlayingNotes model.currentlyPlaying
        ]


viewPiano : AllDict.AllDict ( Model.Octave, Model.Note ) a Float -> Model.Octave -> Html Msg
viewPiano currentlyPlaying selectedOctave =
    div [ class [ Piano ] ] (List.repeat 7 () |> List.indexedMap (\index _ -> viewOctave currentlyPlaying selectedOctave index))

$ elm-package install rtfeldman/elm-css

To install rtfeldman/elm-css I would like to add the following
dependency to elm-package.json:

    "rtfeldman/elm-css": "8.2.0 <= v < 9.0.0"

May I add that to elm-package.json for you? [Y/n] y

Some new packages are needed. Here is the upgrade plan.

  Install:
    elm-lang/core 5.1.1
    elm-lang/html 2.0.0
    elm-lang/virtual-dom 2.0.4
    rtfeldman/elm-css 8.2.0
    rtfeldman/elm-css-util 1.0.2
    rtfeldman/hex 1.0.0

Do you approve of this plan? [Y/n] y

{
    "version": "1.0.0",
    "summary": "helpful summary of your project, less than 80 characters",
    "repository": "https://github.com/user/project.git",
    "license": "BSD3",
    "source-directories": [
        "."
    ],
    "exposed-modules": [],
    "dependencies": {
        "elm-lang/core": "5.1.1 <= v < 6.0.0",
        "elm-lang/html": "2.0.0 <= v < 3.0.0",
        "rtfeldman/elm-css": "8.2.0 <= v < 9.0.0"
    },
    "elm-version": "0.18.0 <= v < 0.19.0"
}

{
    "version": "8.2.0",
    "summary": "CSS Preprocessor for Elm",
    "repository": "https://github.com/rtfeldman/elm-css.git",
    "license": "BSD-3-Clause",
    "source-directories": [
        "src"
    ],
    "exposed-modules": [
        "Css",
        "Css.Colors",
        "Css.Elements",
        "Css.File",
        "Css.Namespace"
    ],
    "dependencies": {
        "elm-lang/core": "5.0.0 <= v < 6.0.0",
        "rtfeldman/elm-css-util": "1.0.2 <= v < 2.0.0",
        "rtfeldman/hex": "1.0.0 <= v < 2.0.0"
    },
    "elm-version": "0.18.0 <= v < 0.19.0"
}

import Css exposing (asPairs, color)
import Css.Colors exposing (green)
import Html.Attributes exposing (style)
import Html exposing (..)
import Html.Events exposing (onClick)

...

view : Int -> Html Msg
view count =
    div [ (style << asPairs) [ color green ] ]
        [ h1 [] [ text "Prairie Chicken, Lesser" ]
        , h2 [] [ text "An Accounting of Hens" ]
        , div []
            [ text (formatChickenCount count)
            ]
        , viewIncrementButton
        , if count > 0 then
            viewDecrementButton
          else
            text ""
        ]

-- HINT:

main =
    program
        { init = init
        , update = update
        , view = view
        , subscriptions = 
            \model -> Sub.none
        }

var node = document.getElementById("some-sweet-id")
var app = Elm.Main.embed(node)