bogdanp/elm-ast

A parser for Elm in Elm.

elm-ast's Issues

Parse error on names starting with `let`

example:

let
   letter = 'a'
in
  0

Error with multi-element records

It seems like {a = a, b = b} should parse to

Record [("a", (Variable ["a"])), ("b", (Variable ["b"]))]

but it causes the errors

failed to parse: {a = a, b = b} at position 0 with errors: ["expected \"let\"","expected \"case\"","expected \"if\"","expected \"\\\\\"","expected '\\''","expected \"\\\"\\\"\\\"\"","expected \"\\\"\"","expected a float","expected an integer","expected \"_\"","expected a lowercase character","expected an uppercase character","expected \"_\"","expected a
lowercase character","expected an uppercase character","expected \"[\"","expected \"[\"","expected \"}\"","expected \"(\""]

Proper parsing for tuples

Cannot export infix functions

module Main exposing ((?))

This code does not parse.

Support destructuring bind

• Function heads ( @baransu #28 )
• Let..in
• Lambda's head
  /Edit by @wende

add positional information to AST

Function declaration in let..in expression causes error

Super cool project! 👍

Here's a little bug I found:

f =
  let
    foo b =
      b
  in
    1

-- (Err (["expected end of input"]),{ input = "f x =\n let\n foo b =\n b\n in\n 1\n", position = 42 })

Why is the Variable constructor: Variable (List Name) rather than Variable Name?

Apologies if this channel is inappropriate, I'm trying to understand the code. Thanks!

Parser fails for string "\\" and similar values

The following declaration in the parser:

x = "\\"

shows the following error:
(Err (["expected end of input"]),{ input = "x = "\\"\n", position = 0 })

In fact, any number of backslashes followed by a single quote fails to parse. While some of those are legitimate errors (odd numbers of backslashes), others aren't (even numbers of backslashes).

Only allow pair (Maybe FunctionTypeDeclaration, FunctionDeclaration) as Statement ?

Since a FunctionTypeDeclaration without a corresponding FunctionDeclaration is not legal (syntax?) in Elm, would it be useful to change:

type Statement
    = ...
    | FunctionTypeDeclaration Name Type
    | FunctionDeclaration Name (List Expression) Expression
    | ...

to:

type alias FunctionTypeDeclaration = FunctionTypeDeclaration Name Type
type alias FunctionDeclaration = FunctionDeclaration Name (List Expression) Expression
type Statement
    = ...
    | FunctionDefinition 
           (Maybe FunctionTypeDeclaration, FunctionDeclaration)
    | ...

with corresponding tweak to parser rules?

AST printer?

Thanks for writing this! I think this will be very useful for an idea I have for converting GraphQL schemas to Elm code. However one key thing that seems to be missing is an AST printer. Is that planned? If not I can try to come up with something.

Fix characters with escape sequences like '\n' or '\x00'

'\t' '\n' '\\' '\x00' etc

AccessFunction is only a syntactic sugar

fn = .field
{- generates 

   AccessFunction [ field ]

   which is only a syntactic sugar for:
-}
fn = \x -> x.field
{- that generates

   Lambda [ Variable [ "x" ] ] (Access (Variable [ "x" ]) [ field ])

   `x` variable used in example has to be different from `field`; 
   may be generated like field ++ "_"
-}

So it seems that additional algebraic element is not needed here. For sake of (model) simplicity it could be removed.

Can't name values starting with keywords

typeFun a = 0 -- Gets treated as type declaration
asFun a = 0  -- won't compile
letter = 'a' -- won't compile

Variables can't be negated with a minus

Taken extracted from https://raw.githubusercontent.com/rundis/elm-bootstrap/3.0.0/src/Bootstrap/Popover.elm

calculatePos pos { rect, offsetWidth, offsetHeight } =
            { left = -offsetWidth
            , top = (rect.height / 2) - (offsetHeight / 2)
            }

Stricter type (alias) for module parser?

The parser result is a list of statements at the moment. Are there any plans to add a stricter/richer type or type alias to only support valid combinations of statements, like only one module declaration at the top of the file? This is partially related to the question in #7. Or should something like this be done in some elm-ast-extra package?

Update for 0.18

Add correct parsing of hex numbers

> 0x000000
0 : number
> 0x0000001
1 : number
> 0x0000201
513 : number
> 0x000020a
522 : number

Parser fails for `i = (*) 2`

Just playing with the live demo, and I noticed i = (*) 2 can't be parsed, so I thought I'd log it. :-)

Parse tuple constructor (,)

Below is an example from List module.

toIndexedList : Array a -> List (Int, a)
toIndexedList array =
  List.map2
    (,)
    (List.range 0 (Native.Array.length array - 1))
    (Native.Array.toList array)

Parsing effect module fails

Parsing of effects module fails. Example:

effect module Task where { command = MyCmd } exposing

Compilation fails when space after/before parens

This works

(a, b)

But this doesn't

( a, b )

Which can be a problem, given that the latter is the default output of elm-format

Make `as` work again

Type assignment in let..in

Can't parse empty record decls

type X = A {}

`::` doesn't compose with other operators

Example:

module Main exposing (..)

a = 
 case a of
   a ->
      a :: "A" ++ 2

Error with multi-element lists

I could be wrong, but it seems like [a, b] should parse to

List [Variable ["a"], Variable ["b"]]

but it parses to

List ([BinOp (Variable [","]) (Variable ["a"]) (Variable ["b"])])

and it gets more complicated as you add more elements.

Parse character escape codes

Parse error for functions with arguments in next line

While testing your great library I've found this case:

import Html exposing (..)

main =
  div []
  [ text "Hello, World!" ]

that compiles on http://elm-lang.org/try, but does not parse on http://bogdanp.github.io/elm-ast/example/.

After modifying to div [] [ text "Hello, World!" ] (one line) code parses correctly.

Not sure do you work on full compatibility, but wanted to report you this issue.

Update online version to represent v 7.0.0 instead of 1.0.0

Fast and correct type parsing written by Elm core team

I found that the package.elm-lang.org frontend perfectly solves the problem for which I have used this library. The type parsing code there might be helpful in this project.

https://github.com/elm-lang/package.elm-lang.org/blob/master/src/frontend/Parse/Type.elm

Parse error: function accessed with module name

typeAttribute = Attributes.type_

Add support for simple destructuring

{a: a} == {a}

Parse error on names starting with `as`

I've found parsing error on some simple code in my fork and tested that this project suffers it too (as long as example page is up to date). This example is extracted from Html module:

node =
  VirtualDom.node

aside =
  node "aside"

Even simpler (seems same case):

node = 0
aside = 7

What's interesting after switching order of functions code parses correctly.

Can't parse type tuples with functions inside

t : (Int, Type -> Type)

Won't work unless a function is wrapped in parens

t : (Int, (Type -> Type))

Idea: add Elm to AST explorer

I just discovered this and thought, Elm could be another supported language here: http://astexplorer.net/

https://github.com/fkling/astexplorer

Fix :: operator associativity

pattern matching on _ failes

fu n =
  case n of
    _ -> 0

Fails to parse.

This works:

fu n =
  case n of
    x -> 0

These also fail:

a _ = 0
b = (\_ -> 0)
c =
  let
    _ = 0
  in
    0

Proper asignment in records

{ a = Just 1 }

right now tries to be interpreted as

{ (a = Just) 1}

Bad performance on arguments in new lines

a b c d e f g h i j k l m

Compiles instantly
while

a 
  b 
  c
  d
  e
  f
  g
  h
  i
  j
  k
  l
  m

Would take couple of minutes

Can't parse record updates as a non-last parameter in a function

a = a { rec | a = 1 } b

Elm-format the project

Comments make parsing fail

f =
  let b = 1 --comment
  in b

The parser does not understand this.

This is probably related to #1, because this, too has to do with newlines.

Split lines don't work in type definitons

example

type alias Type =
    List
       Int

Could be solved in the same manner #45 was

Support `as` in case statement

Function type declaration in let expression

Removing hasImport : List String -> Bool helps, yet this is valid elm code:

compile name =
    let
        hasImport : List String -> Bool
        hasImport name = True
    in
      hasImport name

Incorrect result when using nested case expressions

Hi! I noticed an incorrect AST when parsing something along the likes of

foo =
    case pattern of
        A -> 1
        B ->
            case variable of
                C -> 2
                _ -> 3

        _ ->
            4

Which results in an AST like the following

ast =
    Case (Variable [ "pattern" ])
        ([ ( Variable [ "A" ]
           , Integer 1
           )
         , ( Variable [ "B" ]
           , Case
                (Variable [ "variable" ])
                ([ ( Variable [ "C" ]
                   , Integer 2
                   )
                 , ( Variable [ "_" ], Integer 3 )
                 , ( Variable [ "_" ], Integer 4 )
                 ]
                )
           )
         ]
        )

I expect the first case expression to have 3 patterns (A, B and _ ) and the nested one under B to have 2 (C and _ ), but they respectively have 2 ((A, B) and (C, _ and _ ).

Add support for access as a function

map .someField listOfRecords

Comma binop fixity should be lower than |>

So we can write expressions like:

(a, b |> toString)

that wouldn't compile to

((a,b) |> toString

Parsing error when pattern matching with a variable named alias

Hi! First of all, thanks for making/picking up the package! ❤️

I noticed that parsing fails when I'm pattern matching, and I named one of the variables alias (which is valid Elm code).

This fails:

fn param =
  case param of
    A alias -> 1
    B -> 2

This works:

fn param =
  case param of
    A aliass -> 1
    B -> 2