wende / elchemy Goto Github PK

Example:

a b = 
  case lol b of
    _ -> 2

curry a/1
def a(_) do
  2
end

but it should

curry a/1
def a(b) do
  lol().(b)
end

Example

meta = [
  "use GenServer",
  "defstruct [:something, :else]
]

->

use Genserver
defstruct [:field1, :field2, field3: "default")

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

import String

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

import Tuple

http://package.elm-lang.org/packages/elm-lang/core/5.1.1/Maybe
import Maybe exposing ( Maybe( Just, Nothing ) )

import Debug
http://package.elm-lang.org/packages/elm-lang/core/5.1.1/Debug

Add:

Example:

{-| my function that is awesome -}
function : Awesome
function = Awesome

->

@doc "my function that is awesome"
@spec function :: :awesome
def function(), do: :awesome

This is an AST job because elm-ast sees no difference between block and regular comments

Change defcurry to something nicer like for example:

a b c d = 10

->

curry a/3
def a(b, c, d), do: 10

Or automatically generate curried functions in @before_compile macro

Add:

Example:

first (fst, snd) =
  fst

->

def first({fst, snd}) do
  fst
end

That would make testing with Elmchemy much easier

Example:

{-| Extract the first element of a list.

    head [1,2,3] == Just 1
    head [] == Nothing
-}
head : List a -> Maybe a
head list =
  case list of
    x :: xs ->
      Just x

    [] ->
      Nothing

->

@doc """
 Extract the first element of a list.

    iex> head.([1,2,3])
    1
    iex> head.([])
    nil
"""
@spec head : List a -> Maybe a
def head([x | xs]) do
  x
end
def head([]) do
  nil
end

Add:

Example:

a fn = fn

Right now specs behave incorrectly when we define a function without taking all of the parameters

Example:

someFun : Int -> String
someFun = 
  to_string

->

@spec some_fun(integer) :: String.t
def some_fun() do
  to_string
end

While it's perfectly fine syntax used very often to make default arguments

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

import Result exposing ( Result( Ok, Err ) )

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

From https://github.com/elm-lang/core#default-imports :

• import Basics exposing (..) #25
• import List exposing ( List, (::) ) #60
• import Maybe exposing ( Maybe( Just, Nothing ) ) #61
• import Result exposing ( Result( Ok, Err ) ) #62
• import String #63
• import Tuple #64
• import Debug #65
• import Platform exposing ( Program )
• import Platform.Cmd exposing ( Cmd, (!) )
• import Platform.Sub exposing ( Sub )

Example:

a >> b >> c

->

fn arg -> arg |> a |> b |> c end  

Add:

Example:

fun : (a -> b) -> (a -> b)

->

@spec fun(any -> any) :: (any -> any)

instead of

@spec fun(any) :: anyany) :: any

Example:

elixirE expression context

->

elixirE context expression

Extends #3 and #7
Add:

Example:

fun a b c =
  case (a, b, c) of
    (1, 2, 3) -> 1
    (a, b, c) -> 2

->

defcurry fun(1, 2, 3), do: 1
defcurry fun(a, b, c), do: 1

Example

len li =
  case li of
    [] -> 0
    a :: rest -> 1 + len rest

->

def len([]), do: 0
def len([a | rest]), do: 1 + len(rest)

Add:
Let

Example:

let 
  a = 1
in
  a * 2

->

a = 1
a * 2

Add:

Example:

case t of
  -- Some comment regarding our case
  OurCase c -> 1

->

case t do 
   # Some comment regarding our case
   {:our_case, c} -> 1

Example

a = 2

->

@a 2

How to process messages is still up to a debate:

Temporary solution:

Example:

case receive of
  Msg a -> 1

->

receive do
  {:msg, a} -> 1

But since it's impure, unidiomatic, and totally forbids a case of after block it should be discussed and redeveloped after

Add:

Example:

case a of
  Type _ as m -> 1

->

case a do
  {:type, _} = m -> 1

Add:

Example:

type State a = List a | Map a
fun : State a

->

@spec fun(list(a) | %{})

Add: Simple structs (more than one field is not yet support in ast parser)

Example:

point = {x = 1}
{ point | x = 2 }

->

point = %{x => 1}
%{ point | x => 2 }

Add:

Example:

type alias MyType a = List a
MyType Int

->

list(int)

instead of

list(any)

Advanced Example:

type alias MyType a b = (List a, Maybe b)
MyType Int String

->

{list(int), {String.t} | nil}

instead of

{list(any), any | nil}

Requires major change in AST
Bogdanp/elm-ast/#5

Add:

Example:

GT

->

:gt

instead of

:g_t

Add:

Example:

[(1,1), (1,2)]

->

[{1,1}, {1, 2}]

instead of

[1,1, {1, 2}]

The cause of that is that Lists and Tuples are implemented on binary operator , instead of being parsed as an entity

Add:

Example:

()

->

{}

So, there appears to be a slight typing failure. :-)

Example:

module Stack exposing (..)

type alias TestRecord =
  { int : int
  , float : float
  }

blah : TestRecord
blah =
  42

blorp =
  blah.x

->

# Compiled using Elmchemy v0.0.17
defmodule Stack do
  use Elmchemy

  @spec blah :: %{int: any, float: any}
  curry blah/0
  def blah() do
    42
  end

  curry blorp/0
  def blorp() do
    blah.x
  end

end

As an example, my MLElixir project (which puts a strongly-typed ML face on Elixir, it is not a released project, just something I screw around with for fun, its errors are also very low level and not prettied up at all) compiles the similar code as the above Elm:

iex> import MLElixir
MLElixir
iex> defmlmodule Stack do
...>   type test_record = %{
...>     int: integer,
...>     float: float,
...>   }
...>
...>   let blah | test_record = 42
...>
...>   let blorp = blah.x
...> end

Gives this:

** (throw) {:NO_TYPE_RESOLUTION, %TypedElixir.Type.Const{const: :integer, meta: %{values: '*'}}, %TypedElixir.Type.Const{const: :integer, meta: %{values: '*'}}, %TypedElixir.Type.Record{labels: [int: %TypedElixir.Type.Const{const: :integer, meta: %{}}, float: %TypedElixir.Type.Const{const: :float, meta: %{}}], meta: %{}}}

Which is entirely expected, but currently the above elm code is working in elmchamy when it absolutely should not.

Looking forward to this being developed out. :-)

Example

function
  a
  b
  c

It's a very tricky one.
Since Elm recognizes next argument or case branch based on indentation

For that we need a major change in the parser
Bogdanp/elm-ast#1

Add:

Example:

mod "Some.Module"

->

Some.Module

Add:

Example:

(~~) a b = a ++ b

a ~~ b

->

curry _dashdash/2
def _dashdash(a, b) do
  a + b
end

_dashdash(a, b)

• Code

  • Tuples
  • Atoms
  • Type Applications / Tuples
  • Records
  • Strings, Integers, Lists, Floats
  • Function Declarations
  • Function Applications
  • Module definition, function extraction, and elixir module meta code
  • Typespecs and type aliases ( #13 )

• Standard Library

  • - String module
  • - Basics module
  • - List module
  • - Maybe module

https://github.com/Bogdanp/elm-ast/releases/tag/4.0.0

It requires to look through the types and type aliases of these files though, or otherwise they won't alias properly

Add:

Example:

sortBy .name [chuck,alice,bob]

->

sortBy.(&Map.fetch!(&1, :name)).([chuck,alice,bob])